@nutin/cli 1.3.1 → 2.1.0

package/templates/base/src/core/services/router/helpers/navigation-manager.helper.test.js.hbs

@@ -1,4 +1,6 @@
 import { NavigationManager } from '#root/dist/src/core/services/router/helpers/navigation-manager.helper.js';
+import { I18nService } from '#root/dist/src/core/services/index.js';
+import { CONFIG } from '#root/dist/src/core/config.js';
 
 describe('NavigationManager', () => {
   it('should normalize paths by removing trailing slashes', () => {
@@ -8,12 +10,6 @@ describe('NavigationManager', () => {
     expect(NavigationManager.normalizePath('')).toBe('/');
   });
 
-  it('should determine if pushState should be used', () => {
-    expect(NavigationManager.shouldPushState(true, '/home', '/about')).toBe(true);
-    expect(NavigationManager.shouldPushState(false, '/home', '/about')).toBe(false);
-    expect(NavigationManager.shouldPushState(true, '/about', '/about')).toBe(false);
-  });
-
   it('should call pushState when conditions are met', () => {
     const originalPushState = window.history.pushState;
     let called = false;
@@ -48,4 +44,259 @@ describe('NavigationManager', () => {
     const currentPath = window.location.pathname;
     expect(NavigationManager.getCurrentPath()).toBe(currentPath);
   });
+
+  it('extractLocale returns the original path untouched when CONFIG.i18n is disabled', () => {
+    CONFIG.i18n = false;
+    expect(NavigationManager.extractLocale('/fr/about')).toEqual({ locale: null, strippedPath: '/fr/about' });
+  });
+
+  it('extractLocale strips a recognized locale prefix when CONFIG.i18n is enabled', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    try {
+      expect(NavigationManager.extractLocale('/fr/about')).toEqual({ locale: 'fr', strippedPath: '/about' });
+      expect(NavigationManager.extractLocale('/fr')).toEqual({ locale: 'fr', strippedPath: '/' });
+    } finally {
+      CONFIG.i18n = false;
+    }
+  });
+
+  it('extractLocale leaves the path untouched when the first segment is not a recognized locale', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    try {
+      expect(NavigationManager.extractLocale('/about')).toEqual({ locale: null, strippedPath: '/about' });
+    } finally {
+      CONFIG.i18n = false;
+    }
+  });
+
+  it('addLocalePrefix returns the path unchanged when CONFIG.i18n is disabled', () => {
+    CONFIG.i18n = false;
+    expect(NavigationManager.addLocalePrefix('/about')).toBe('/about');
+  });
+
+  it('addLocalePrefix prefixes the path with the current language when CONFIG.i18n is enabled', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    I18nService['_currentLanguage'] = 'fr';
+    try {
+      expect(NavigationManager.addLocalePrefix('/about')).toBe('/fr/about');
+      expect(NavigationManager.addLocalePrefix('/')).toBe('/fr');
+    } finally {
+      CONFIG.i18n = false;
+      I18nService['_currentLanguage'] = 'en';
+    }
+  });
+
+  it('getCurrentLocale reads the locale from the current URL path when CONFIG.i18n is enabled', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    window.history.pushState({}, '', '/fr/about');
+    try {
+      expect(NavigationManager.getCurrentLocale()).toBe('fr');
+    } finally {
+      CONFIG.i18n = false;
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('getCurrentLocale returns null when CONFIG.i18n is disabled', () => {
+    window.history.pushState({}, '', '/fr/about');
+    try {
+      expect(NavigationManager.getCurrentLocale()).toBe(null);
+    } finally {
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('updateLocaleInUrl pushes a new URL when the locale-prefixed path differs from the current one', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    I18nService['_currentLanguage'] = 'fr';
+    window.history.pushState({}, '', '/about');
+
+    const originalPushState = window.history.pushState;
+    const calls = [];
+    window.history.pushState = (...args) => {
+      calls.push(args);
+      originalPushState.apply(window.history, args);
+    };
+
+    try {
+      NavigationManager.updateLocaleInUrl();
+      expect(calls.length).toBe(1);
+      expect(calls[0][2]).toBe('/fr/about');
+    } finally {
+      window.history.pushState = originalPushState;
+      CONFIG.i18n = false;
+      I18nService['_currentLanguage'] = 'en';
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('updateLocaleInUrl handles a root pathname that collapses to an empty string when stripped', () => {
+    CONFIG.i18n = false;
+    window.history.pushState({}, '', '/');
+
+    const originalPushState = window.history.pushState;
+    window.history.pushState = () => {};
+
+    try {
+      expect(() => NavigationManager.updateLocaleInUrl()).not.toThrow();
+    } finally {
+      window.history.pushState = originalPushState;
+    }
+  });
+
+  it('updateLocaleInUrl does nothing when the URL already has the correct locale prefix', () => {
+    CONFIG.i18n = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    I18nService['_currentLanguage'] = 'fr';
+    window.history.pushState({}, '', '/fr/about');
+
+    const originalPushState = window.history.pushState;
+    let called = false;
+    window.history.pushState = () => { called = true; };
+
+    try {
+      NavigationManager.updateLocaleInUrl();
+      expect(called).toBe(false);
+    } finally {
+      window.history.pushState = originalPushState;
+      CONFIG.i18n = false;
+      I18nService['_currentLanguage'] = 'en';
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('matchPattern matches a required param', () => {
+    expect(NavigationManager.matchPattern('/posts/:id', '/posts/123')).toEqual({ id: '123' });
+  });
+
+  it('matchPattern does not match when a required param segment is missing', () => {
+    expect(NavigationManager.matchPattern('/posts/:id', '/posts')).toBe(null);
+  });
+
+  it('matchPattern matches an optional param when present, and omits it when absent', () => {
+    expect(NavigationManager.matchPattern('/users/:id?', '/users/123')).toEqual({ id: '123' });
+    expect(NavigationManager.matchPattern('/users/:id?', '/users')).toEqual({});
+  });
+
+  it('matchPattern matches multiple params in the same pattern', () => {
+    expect(NavigationManager.matchPattern('/posts/:postId/comments/:commentId', '/posts/1/comments/2'))
+      .toEqual({ postId: '1', commentId: '2' });
+  });
+
+  it('matchPattern returns null when the path does not match the pattern at all', () => {
+    expect(NavigationManager.matchPattern('/posts/:id', '/other/123')).toBe(null);
+  });
+
+  it('updateDocumentTitle falls back to the view\'s viewName when generateSEOFiles is disabled', () => {
+    CONFIG.generateSEOFiles = false;
+    CONFIG.seo = { routes: [{ path: '/', title: 'Should not be used' }] };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('home');
+    } finally {
+      CONFIG.generateSEOFiles = false;
+    }
+  });
+
+  it('updateDocumentTitle falls back to the view\'s viewName when no seo.json route matches the pattern', () => {
+    CONFIG.generateSEOFiles = true;
+    CONFIG.seo = { routes: [{ path: '/other', title: 'Other' }] };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('home');
+    } finally {
+      CONFIG.generateSEOFiles = false;
+    }
+  });
+
+  it('updateDocumentTitle uses a flat seo.json title when generateSEOFiles is enabled and the pattern matches', () => {
+    CONFIG.generateSEOFiles = true;
+    CONFIG.seo = { routes: [{ path: '/', title: 'My App — Home' }] };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('My App — Home');
+    } finally {
+      CONFIG.generateSEOFiles = false;
+    }
+  });
+
+  it('updateDocumentTitle resolves a per-language seo.json title to the current language', () => {
+    CONFIG.generateSEOFiles = true;
+    CONFIG.seo = { routes: [{ path: '/', title: { en: 'Home', fr: 'Accueil' } }] };
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+    I18nService['_currentLanguage'] = 'fr';
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('Accueil');
+    } finally {
+      CONFIG.generateSEOFiles = false;
+      I18nService['_currentLanguage'] = 'en';
+    }
+  });
+
+  it('updateDocumentTitle falls back to the default language, then any available language, then viewName', () => {
+    CONFIG.generateSEOFiles = true;
+    I18nService['_LANGUAGES'] = ['en', 'fr'];
+
+    CONFIG.seo = { routes: [{ path: '/', title: { fr: 'Accueil' } }] };
+    I18nService['_currentLanguage'] = 'en';
+    try {
+      // current lang ('en') missing -> falls back to default lang's value, present here as 'fr' only,
+      // so it falls further to the first available value
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('Accueil');
+
+      CONFIG.seo = { routes: [{ path: '/', title: {} }] };
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('home');
+    } finally {
+      CONFIG.generateSEOFiles = false;
+      I18nService['_currentLanguage'] = 'en';
+    }
+  });
+
+  it('updateDocumentTitle uses the view\'s locale title when i18n is enabled and no seo.json route matches', () => {
+    CONFIG.i18n = true;
+    CONFIG.generateSEOFiles = false;
+    I18nService['_translations'] = { home: { title: 'Accueil' } };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('Accueil');
+    } finally {
+      CONFIG.i18n = false;
+      I18nService['_translations'] = {};
+    }
+  });
+
+  it('updateDocumentTitle prefers seo.json title over the locale title when both are present', () => {
+    CONFIG.i18n = true;
+    CONFIG.generateSEOFiles = true;
+    CONFIG.seo = { routes: [{ path: '/', title: 'From seo.json' }] };
+    I18nService['_translations'] = { home: { title: 'From locale' } };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('From seo.json');
+    } finally {
+      CONFIG.i18n = false;
+      CONFIG.generateSEOFiles = false;
+      I18nService['_translations'] = {};
+    }
+  });
+
+  it('updateDocumentTitle ignores the locale title when i18n is disabled, falling back to viewName', () => {
+    CONFIG.i18n = false;
+    CONFIG.generateSEOFiles = false;
+    I18nService['_translations'] = { home: { title: 'Should not be used' } };
+    try {
+      NavigationManager.updateDocumentTitle({ viewName: 'home' }, '/');
+      expect(document.title).toBe('home');
+    } finally {
+      I18nService['_translations'] = {};
+    }
+  });
 });

package/templates/base/src/core/services/router/helpers/navigation-manager.helper.ts.hbs

@@ -1,13 +1,48 @@
-import { {{#if i18n}}I18nService, {{/if}}View } from "../../../index.js";
+import { I18nService, View } from "../../../index.js";
+import { Language } from "../../i18n/languages.js";
+import { CONFIG } from "../../../config.js";
 
 /**
  * Navigation - handles path normalization and history management
  */
 export class NavigationManager {
+  public static extractLocale(path: string): { locale: Language | null; strippedPath: string } {
+    if (!CONFIG.i18n) return { locale: null, strippedPath: path };
+
+    const segments = path.split('/').filter(Boolean);
+    const first = segments[0] as Language;
+    if (first && I18nService.languages.includes(first)) {
+      const rest = segments.slice(1).join('/');
+      return { locale: first, strippedPath: rest ? `/${rest}` : '/' };
+    }
+    return { locale: null, strippedPath: path };
+  }
+
+  public static addLocalePrefix(strippedPath: string): string {
+    if (!CONFIG.i18n) return strippedPath;
+
+    const lang = I18nService.currentLanguage;
+    return strippedPath === '/' ? `/${lang}` : `/${lang}${strippedPath}`;
+  }
+
+  public static getCurrentLocale(): Language | null {
+    return this.extractLocale(window.location.pathname).locale;
+  }
+
+  public static updateLocaleInUrl(): void {
+    const rawPathname = (new URL(window.location.pathname, window.location.origin).pathname || '/').replace(/\/+$/, '') || '/';
+    const { strippedPath } = this.extractLocale(rawPathname);
+    const newUrl = this.addLocalePrefix(strippedPath);
+    if (newUrl !== window.location.pathname) {
+      window.history.pushState({}, '', newUrl);
+    }
+  }
+
   public static normalizePath(path: string): string {
     const collapsed = path.replace(/\/\/+/g, '/');
     const url = new URL(collapsed, window.location.origin);
-    return (url.pathname || '/').replace(/\/+$/, '') || '/';
+    const pathname = (url.pathname || '/').replace(/\/+$/, '') || '/';
+    return this.extractLocale(pathname).strippedPath;
   }
 
   public static updateHistory(
@@ -15,32 +50,32 @@ export class NavigationManager {
     currentPath: string,
     pushState: boolean
   ): void {
-    if (this.shouldPushState(pushState, currentPath, normalizedPath)) {
-      window.history.pushState({}, '', normalizedPath);
+    const localizedPath = this.addLocalePrefix(normalizedPath);
+    if (pushState && window.location.pathname !== localizedPath) {
+      window.history.pushState({}, '', localizedPath);
     }
   }
 
-  public static updateMetaContent(currentView: View): void {
-    if (!currentView.shouldUpdateMetaContent()) return;
-
-    const strippedName = currentView.viewName.replace('-view', '');
-    {{#if i18n}}
-    const title = `${strippedName}.meta.title`;
-    const description = `${strippedName}.meta.description`;
-
-    document.title = I18nService.translate(title);
-    document.querySelector('meta[name="description"]')
-      ?.setAttribute('content', I18nService.translate(description));
-    {{else}}
-    
-    document.title = strippedName.charAt(0).toUpperCase() + strippedName.slice(1).toLowerCase();
-    {{/if}}
-  }
-
   public static getCurrentPath(): string {
     return this.normalizePath(window.location.pathname);
   }
 
+  public static updateDocumentTitle(view: View, pattern: string): void {
+    const route = CONFIG.generateSEOFiles
+      ? CONFIG.seo?.routes?.find((r) => r.path === pattern)
+      : undefined;
+    const seoTitle = route?.title ? this.resolveSeoTitle(route.title) : undefined;
+    const localeTitle = CONFIG.i18n ? I18nService.getTranslationObject<string>(`${view.viewName}.title`) : null;
+    document.title = seoTitle || localeTitle || view.viewName;
+  }
+
+  private static resolveSeoTitle(title: string | Record<string, string>): string | undefined {
+    if (typeof title !== 'object') return title;
+    const lang = I18nService.currentLanguage;
+    const defaultLang = I18nService.defaultLanguage;
+    return title[lang] ?? title[defaultLang] ?? Object.values(title)[0];
+  }
+
   public static matchPattern(pattern: string, path: string): Record<string, string> | null {
     const paramNames: string[] = [];
 
@@ -68,12 +103,4 @@ export class NavigationManager {
     });
     return params;
   }
-
-  private static shouldPushState(
-    pushState: boolean,
-    currentPath: string,
-    normalizedPath: string
-  ): boolean {
-    return pushState && currentPath !== normalizedPath;
-  }
 }

package/templates/base/src/core/services/router/helpers/route-guard-manager.helper.test.js.hbs

@@ -29,6 +29,12 @@ describe('RouteGuardsManager', () => {
     expect(JSON.stringify(result)).toBe(JSON.stringify([guard]));
   });
 
+  it('should default to an empty guards array when an object route config has no guards', () => {
+    const config = { view: mockViewConstructor };
+    const result = RouteGuardsManager.getRouteGuards(config);
+    expect(result).toEqual([]);
+  });
+
   it('should pass all guards and return true from runGuards', async () => {
     const guards = [() => true, () => Promise.resolve(true)];
     const result = await RouteGuardsManager.runGuards(guards);
@@ -70,4 +76,25 @@ describe('RouteGuardsManager', () => {
     expect(typeof result.viewConstructor).toBe('function');
     expect(result.redirectTo).toBeUndefined();
   });
+
+  it('passes the actual route params through processRouteGuards to each guard', async () => {
+    const receivedParams = [];
+    const guard = (params) => { receivedParams.push(params); return true; };
+    const config = { view: mockViewConstructor, guards: [guard] };
+
+    await RouteGuardsManager.processRouteGuards(config, '/users/42', { id: '42' });
+
+    expect(receivedParams.length).toBe(1);
+    expect(receivedParams[0]).toEqual({ id: '42' });
+  });
+
+  it('defaults params to an empty object when none are passed to processRouteGuards', async () => {
+    const receivedParams = [];
+    const guard = (params) => { receivedParams.push(params); return true; };
+    const config = { view: mockViewConstructor, guards: [guard] };
+
+    await RouteGuardsManager.processRouteGuards(config, '/dashboard');
+
+    expect(receivedParams[0]).toEqual({});
+  });
 });

package/templates/base/src/core/services/router/helpers/view-render-manager.helper.test.js.hbs

@@ -26,24 +26,11 @@ describe('ViewRenderManager', () => {
         return el;
       },
       destroy: () => {},
+      onEnter: () => {},
+      onExit: () => {},
     };
   };
 
-{{#if animation}}
-  it('should add exit class and destroy current view on transition out', async () => {
-    const view = mockView();
-    const el = view.render();
-    container.appendChild(el);
-
-    // Spy on destroy
-    const spy = spyOn(view, 'destroy');
-
-    await ViewRenderManager.transitionOutCurrentView(view);
-
-    expect(spy).toHaveBeenCalled();
-  });
-
-{{/if}}
   it('should do nothing if no current view is passed to transitionOutCurrentView', async () => {
     const result = await ViewRenderManager.transitionOutCurrentView(null);
     expect(result).toBe(null);
@@ -51,7 +38,8 @@ describe('ViewRenderManager', () => {
 
   it('should emit view-unmount event on transition out', async () => {
     const emitted = [];
-    AppEventBus.emit = (event, data) => emitted.push({ event, data });
+    const emitSpy = spyOn(AppEventBus, 'emit');
+    emitSpy.andCallFake((event, data) => emitted.push({ event, data }));
 
     const view = mockView('SettingsView');
     const el = view.render();
@@ -59,6 +47,84 @@ describe('ViewRenderManager', () => {
 
     await ViewRenderManager.transitionOutCurrentView(view);
 
-    expect(JSON.stringify(emitted)).toContain(JSON.stringify({ event: 'view-unmount', data: 'SettingsView' }));
+    expect(JSON.stringify(emitted)).toContain(JSON.stringify({ event: 'view-unmount', data: { viewName: 'SettingsView' } }));
+    emitSpy.restore();
+  });
+
+  it('should call destroy() and onExit() on the current view when transitioning out', async () => {
+    let destroyed = false;
+    let exited = false;
+    const view = mockView('SettingsView');
+    view.destroy = () => { destroyed = true; };
+    view.onExit = () => { exited = true; };
+
+    await ViewRenderManager.transitionOutCurrentView(view);
+
+    expect(destroyed).toBe(true);
+    expect(exited).toBe(true);
+  });
+
+  it('should set route params, render, call onEnter and emit view-mount when rendering a new view', () => {
+    const emitted = [];
+    const emitSpy = spyOn(AppEventBus, 'emit');
+    emitSpy.andCallFake((event, data) => emitted.push({ event, data }));
+
+    const calls = [];
+    const viewElement = document.createElement('div');
+    const view = {
+      viewName: 'HomeView',
+      getElement: () => viewElement,
+      setRouteParams: (params) => calls.push(['setRouteParams', params]),
+      render: () => { calls.push(['render']); return viewElement; },
+      onEnter: () => calls.push(['onEnter']),
+    };
+
+    ViewRenderManager.renderNewView(() => view, { id: '42' });
+
+    expect(calls).toEqual([
+      ['setRouteParams', { id: '42' }],
+      ['render'],
+      ['onEnter'],
+    ]);
+    expect(JSON.stringify(emitted)).toContain(JSON.stringify({ event: 'view-mount', data: { viewName: 'HomeView' } }));
+    emitSpy.restore();
+  });
+
+  it('should not attempt to clear stale content when the new view has no parent element yet', () => {
+    const viewElement = document.createElement('div');
+    // Note: viewElement is intentionally never attached to the container.
+    const view = {
+      viewName: 'HomeView',
+      getElement: () => viewElement,
+      setRouteParams: () => {},
+      render: () => viewElement,
+      onEnter: () => {},
+    };
+
+    expect(() => ViewRenderManager.renderNewView(() => view)).not.toThrow();
+  });
+
+  it('should clear stale mount content before rendering the new view', () => {
+    const stale = document.createElement('div');
+    stale.className = 'stale-seo-content';
+    container.appendChild(stale);
+
+    const viewElement = document.createElement('div');
+    viewElement.className = 'mock-view';
+    container.appendChild(viewElement);
+
+    const view = {
+      viewName: 'HomeView',
+      getElement: () => viewElement,
+      setRouteParams: () => {},
+      render: () => viewElement,
+      onEnter: () => {},
+    };
+
+    ViewRenderManager.renderNewView(() => view);
+
+    expect(container.children.length).toBe(1);
+    expect(container.contains(stale)).toBe(false);
+    expect(container.contains(viewElement)).toBe(true);
   });
 });

package/templates/base/src/core/services/router/helpers/view-render-manager.helper.ts.hbs

@@ -1,35 +1,14 @@
-import { View, AppEventBus } from '../../../index.js';
+import { View, Lifecycle } from '../../../index.js';
 
 /**
- * handles all view rendering{{#if transition}} and transition animation logic{{/if}}.
+ * handles all view rendering.
  */
 export class ViewRenderManager {
-  {{#if transition}}
-  public static renderAnimatedView(view: View): void {
-    const container = document.getElementById('app');
-    const el = view.render();
-    el.classList.add('app-view-transition');
-    container?.appendChild(el);
-    
-    requestAnimationFrame(() => {
-      el.classList.add('enter-active');
-    });
-  }
-
-  {{/if}}
   public static async transitionOutCurrentView(currentView: View | null): Promise<null> {
     if (!currentView) return null;
-    {{#if transition}}
-    const container = document.getElementById('app');
-    const el = container?.firstElementChild as HTMLElement;
-
-    if (el) {
-      el.classList.add('exit-active');
-      await this.delay(300); // match transition duration in _libs.scss
-    }
-    {{/if}}
     currentView.destroy();
-    this.emitEvent('view-unmount', currentView.viewName);
+    currentView.onExit();
+    Lifecycle.viewUnmount(currentView.viewName);
     return null;
   }
 
@@ -38,28 +17,25 @@ export class ViewRenderManager {
     params: Record<string, string> = {}
   ): View {
     const view = viewConstructor();
+    ViewRenderManager.clearStaleMountContent(view);
 
     // Set route parameters before rendering
     view.setRouteParams(params);
 
-    {{#if transition}}
-    this.renderAnimatedView(view);
-
-    {{else}}
     view.render();
+    view.onEnter();
 
-    {{/if}}
-    this.emitEvent('view-mount', view.viewName);
+    Lifecycle.viewMount(view.viewName);
     return view;
   }
 
-  private static emitEvent(event: EventKey, viewName: string): void {
-    AppEventBus.emit(event, viewName);
-  }
-  {{#if transition}}
+  private static clearStaleMountContent(view: View): void {
+    const viewElement = view.getElement();
+    const container = viewElement.parentElement;
+    if (!container) return;
 
-  private static delay(ms: number): Promise<void> {
-    return new Promise(res => setTimeout(res, ms));
+    Array.from(container.childNodes).forEach((node) => {
+      if (node !== viewElement) node.remove();
+    });
   }
-  {{/if}}
 }