@nutin/cli 1.3.0 → 2.0.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,151 @@ 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);
+  });
 });

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

@@ -1,12 +1,48 @@
-import { {{#if i18n}}I18nService, {{/if}}View } from "../../../index.js";
+import { I18nService } 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 url = new URL(path, window.location.origin);
-    return (url.pathname || '/').replace(/\/+$/, '') || '/';
+    const collapsed = path.replace(/\/\/+/g, '/');
+    const url = new URL(collapsed, window.location.origin);
+    const pathname = (url.pathname || '/').replace(/\/+$/, '') || '/';
+    return this.extractLocale(pathname).strippedPath;
   }
 
   public static updateHistory(
@@ -14,28 +50,12 @@ 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);
   }
@@ -67,12 +87,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,61 +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.cleanupOptionalContent();
-
-    this.emitEvent('view-mount', view.viewName);
+    Lifecycle.viewMount(view.viewName);
     return view;
   }
 
-  public static cleanupOptionalContent(): void {
-    const isEmpty = (el: HTMLElement): boolean => {
-      const attrName = el.dataset.optional?.trim();
-
-      if (attrName && attrName !== "") {
-        const attrValue = el.getAttribute(attrName);
-        return !attrValue || attrValue.trim() === "" || attrValue === "undefined";
-      }
+  private static clearStaleMountContent(view: View): void {
+    const viewElement = view.getElement();
+    const container = viewElement.parentElement;
+    if (!container) return;
 
-      if (el instanceof HTMLImageElement) {
-        return !el.src || el.src.trim() === "";
-      }
-
-      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
-        return !el.value?.trim();
-      }
-
-      if (el instanceof HTMLMediaElement || el instanceof HTMLSourceElement) {
-        return !el.getAttribute("src");
-      }
-
-      const content = el.textContent?.trim();
-      return !content || content === "undefined";
-    };
-
-    document.querySelectorAll<HTMLElement>("[data-optional]").forEach(el => {
-      if (isEmpty(el)) el.remove();
+    Array.from(container.childNodes).forEach((node) => {
+      if (node !== viewElement) node.remove();
     });
   }
-
-  private static emitEvent(event: EventKey, viewName: string): void {
-    AppEventBus.emit(event, viewName);
-  }
-  {{#if transition}}
-
-  private static delay(ms: number): Promise<void> {
-    return new Promise(res => setTimeout(res, ms));
-  }
-  {{/if}}
 }