@nutin/cli 1.3.1 → 2.0.0

package/templates/base/src/core/services/index.ts.hbs

@@ -1,8 +1,7 @@
-export * from './event-bus/event-bus.js';
+export * from './event-bus/index.js';
+export * from './globals/globals.js';
 export * from './http-client/http-client.js';
-export * from './router/router.js';
-export * from './store/store.js';
-export * from './pipe-registry/pipe-registry.js';
-{{#if i18n}}
 export * from './i18n/i18n.js';
-{{/if}}
+export * from './pipe-registry/pipe-registry.js';
+export * from './pipe-registry/pipes.js';
+export * from './router/router.js';

package/templates/base/src/core/services/pipe-registry/pipe-registry.test.js.hbs

@@ -1,7 +1,66 @@
 import { AppPipeRegistry } from '#root/dist/src/core/services/index.js';
+import { registerPipes } from '#root/dist/src/core/services/pipe-registry/pipes.js';
 
 describe('PipeRegistry', () => {
 	it('should be defined', () => {
 		expect(AppPipeRegistry).toBeDefined();
-	})
+	});
+
+	it('register() makes a pipe available via apply()', () => {
+		AppPipeRegistry.register('reverse-test', (value) => String(value).split('').reverse().join(''));
+		expect(AppPipeRegistry.apply('reverse-test', 'abc')).toBe('cba');
+	});
+
+	it('apply() passes extra args through to the pipe function', () => {
+		AppPipeRegistry.register('pad-test', (value, char) => `${char}${value}${char}`);
+		expect(AppPipeRegistry.apply('pad-test', 'x', ['*'])).toBe('*x*');
+	});
+
+	it('register() keeps the original implementation when the name is already registered', () => {
+		const warnSpy = spyOn(console, 'warn');
+		warnSpy.andCallFake(() => {});
+
+		AppPipeRegistry.register('dup-test', () => 'first');
+
+		AppPipeRegistry.register('dup-test', () => 'second');
+
+		expect(AppPipeRegistry.apply('dup-test', 'ignored')).toBe('first');
+
+		expect(warnSpy.callCount).toBe(1);
+		warnSpy.restore();
+	});
+
+	it('apply() warns and returns the raw value when the pipe is not registered', () => {
+		const warnSpy = spyOn(console, 'warn');
+		warnSpy.andCallFake(() => {});
+
+		const result = AppPipeRegistry.apply('does-not-exist', 'raw-value');
+
+		expect(result).toBe('raw-value');
+		expect(warnSpy.callCount).toBe(1);
+
+		warnSpy.restore();
+	});
+
+	it('onDestroy() clears all registered pipes', () => {
+		AppPipeRegistry.register('clear-test', (v) => v);
+		expect(AppPipeRegistry.apply('clear-test', 'x')).toBe('x');
+
+		AppPipeRegistry.onDestroy();
+
+		const warnSpy = spyOn(console, 'warn');
+		warnSpy.andCallFake(() => {});
+
+		expect(AppPipeRegistry.apply('clear-test', 'x')).toBe('x');
+		expect(warnSpy.callCount).toBe(1);
+
+		warnSpy.restore();
+
+		// AppPipeRegistry is a process-wide singleton shared by every test suite,
+		// so destroying it here would otherwise leak into every suite that runs
+		// afterward and relies on the app's pipes already being registered. Silenced
+		// since this can legitimately re-hit an "already exists" warning per pipe if
+		// some other suite re-registers them again later in the run.
+		silenceConsole('warn', () => registerPipes());
+	});
 });

package/templates/base/src/core/services/pipe-registry/pipe-registry.ts.hbs

@@ -9,7 +9,7 @@ class PipeRegistry extends Service<PipeRegistry> {
 
   public register(name: string, fn: PipeFunction): void {
     if(this._pipes[name]) {
-      console.warn(`Skipping pipe "${name}": A pipe with this name already exists.`);
+      console.warn(`Pipe "${name}" already exists - skipping.`);
       return;
     }
     this._pipes[name] = fn;

package/templates/base/src/core/services/pipe-registry/pipes.test.js.hbs

@@ -0,0 +1,128 @@
+import { registerPipes } from '#root/dist/src/core/services/pipe-registry/pipes.js';
+import { AppPipeRegistry } from '#root/dist/src/core/index.js';
+
+describe('pipes (registerPipes)', () => {
+  beforeAll(() => {
+    // AppPipeRegistry is a process-wide singleton shared by every suite in the
+    // run - if an earlier suite (e.g. pipe-registry.test.js) already re-registered
+    // the app's pipes, this call is a legitimate no-op that logs a "already exists"
+    // warning per pipe. Silence that expected noise rather than letting it leak.
+    silenceConsole('warn', () => registerPipes());
+  });
+
+  it('currency formats a number as USD/en-US by default', () => {
+    const expected = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(1234.5);
+    expect(AppPipeRegistry.apply('currency', 1234.5)).toBe(expected);
+  });
+
+  it('currency accepts a custom currency and locale via args', () => {
+    const expected = new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(1000);
+    expect(AppPipeRegistry.apply('currency', 1000, ['EUR', 'de-DE'])).toBe(expected);
+  });
+
+  it('date formats using the "long" format by default', () => {
+    const value = '2024-03-15T00:00:00Z';
+    const expected = new Date(value).toLocaleString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+    expect(AppPipeRegistry.apply('date', value, ['en-US'])).toBe(expected);
+  });
+
+  it('date formats using the "short" format when requested', () => {
+    const value = '2024-03-15T00:00:00Z';
+    const expected = new Date(value).toLocaleString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'short'])).toBe(expected);
+  });
+
+  it('date formats using the "time" format when requested', () => {
+    const value = '2024-03-15T14:30:00Z';
+    const expected = new Date(value).toLocaleString('en-US', { hour: '2-digit', minute: '2-digit' });
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'time'])).toBe(expected);
+  });
+
+  it('date falls back to the "long" format for an unrecognized format name', () => {
+    const value = '2024-03-15T00:00:00Z';
+    const expected = new Date(value).toLocaleString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'nonsense'])).toBe(expected);
+  });
+
+  it('date includes hour/minute in short/long formats when the time flag is set', () => {
+    const value = '2024-03-15T14:30:00Z';
+    const expected = new Date(value).toLocaleString('en-US', {
+      year: 'numeric', month: 'long', day: 'numeric', hour: '2-digit', minute: '2-digit',
+    });
+    expect(AppPipeRegistry.apply('date', value, ['en-US', 'long', true])).toBe(expected);
+  });
+
+  it('date warns and returns the raw stringified value for an invalid date', () => {
+    const warnSpy = spyOn(console, 'warn');
+    warnSpy.andCallFake(() => {});
+
+    const result = AppPipeRegistry.apply('date', 'not-a-date', ['en-US']);
+
+    expect(result).toBe('not-a-date');
+    expect(warnSpy.callCount).toBe(1);
+    warnSpy.restore();
+  });
+
+  it('number defaults to 0 decimal places', () => {
+    expect(AppPipeRegistry.apply('number', 3.14159)).toBe('3');
+  });
+
+  it('number respects an explicit decimals arg', () => {
+    expect(AppPipeRegistry.apply('number', 3.14159, ['2'])).toBe('3.14');
+  });
+
+  it('uppercase converts to upper case', () => {
+    expect(AppPipeRegistry.apply('uppercase', 'hello')).toBe('HELLO');
+  });
+
+  it('lowercase converts to lower case', () => {
+    expect(AppPipeRegistry.apply('lowercase', 'HELLO')).toBe('hello');
+  });
+
+  it('capitalize uppercases only the first letter and lowercases the rest', () => {
+    expect(AppPipeRegistry.apply('capitalize', 'HELLO world')).toBe('Hello world');
+  });
+
+  it('capitalizeAll capitalizes the first letter of every word', () => {
+    expect(AppPipeRegistry.apply('capitalizeAll', 'hello world')).toBe('Hello World');
+  });
+
+  it('capitalizeAll capitalizes after separators like comma and period', () => {
+    expect(AppPipeRegistry.apply('capitalizeAll', 'hello, world. goodbye')).toBe('Hello, World. Goodbye');
+  });
+
+  it('capitalizeAll does not capitalize a letter immediately following an apostrophe', () => {
+    expect(AppPipeRegistry.apply('capitalizeAll', "o'brien's house")).toBe("O'brien's House");
+  });
+
+  it('truncate leaves a string shorter than the given length unchanged', () => {
+    expect(AppPipeRegistry.apply('truncate', 'Hi', ['5'])).toBe('Hi');
+  });
+
+  it('truncate cuts a longer string and appends the default suffix', () => {
+    expect(AppPipeRegistry.apply('truncate', 'Hello World', ['5'])).toBe('Hello...');
+  });
+
+  it('truncate accepts a custom suffix', () => {
+    expect(AppPipeRegistry.apply('truncate', 'Hello World', ['5', '---'])).toBe('Hello---');
+  });
+
+  it('default returns the value unchanged when it is truthy', () => {
+    expect(AppPipeRegistry.apply('default', 'value', ['N/A'])).toBe('value');
+  });
+
+  it('default falls back to the given default when the value is falsy', () => {
+    expect(AppPipeRegistry.apply('default', '', ['N/A'])).toBe('N/A');
+    expect(AppPipeRegistry.apply('default', 0, ['N/A'])).toBe('N/A');
+  });
+
+  it('json pretty-prints a plain value', () => {
+    expect(AppPipeRegistry.apply('json', { a: 1 })).toBe(JSON.stringify({ a: 1 }, null, 2));
+  });
+
+  it('json falls back to String(value) when JSON.stringify throws (e.g. a circular reference)', () => {
+    const circular = {};
+    circular.self = circular;
+    expect(AppPipeRegistry.apply('json', circular)).toBe(String(circular));
+  });
+});

package/templates/base/src/{libs/pipes → core/services/pipe-registry}/pipes.ts.hbs

@@ -1,4 +1,4 @@
-import { AppPipeRegistry } from "../../core/index.js";
+import { AppPipeRegistry } from "./pipe-registry.js";
 
 export const registerPipes = (): void => {    
   // currency
@@ -21,9 +21,12 @@ export const registerPipes = (): void => {
     time = false,
   ) => {
     const date = new Date(value);
+    // '' is not a valid Intl.DateTimeFormatOptions value for hour/minute, so
+    // omit those keys entirely rather than setting them when time is false.
+    const timeOptions: Intl.DateTimeFormatOptions = time ? { hour: '2-digit', minute: '2-digit' } : {};
     const formats = {
-      short: { year: 'numeric', month: 'short', day: 'numeric', hour: time ? '2-digit' : '', minute: time ? '2-digit' : '' } as Intl.DateTimeFormatOptions,
-      long: { year: 'numeric', month: 'long', day: 'numeric', hour: time ? '2-digit' : '', minute: time ? '2-digit' : '' } as Intl.DateTimeFormatOptions,
+      short: { year: 'numeric', month: 'short', day: 'numeric', ...timeOptions } as Intl.DateTimeFormatOptions,
+      long: { year: 'numeric', month: 'long', day: 'numeric', ...timeOptions } as Intl.DateTimeFormatOptions,
       time: { hour: '2-digit', minute: '2-digit' } as Intl.DateTimeFormatOptions
     };
 
@@ -51,10 +54,10 @@ export const registerPipes = (): void => {
   });
   AppPipeRegistry.register('capitalizeAll', (value) => {
     const str = String(value);
-    return str.replace(/(^|[ .,"'])\s*([a-z])/g, (match, separator, char, offset) => {
+    return str.replace(/(^|[ .,"'])(\s*)([a-z])/g, (match, separator, whitespace, char, offset) => {
     // Don't capitalize if preceded by a single quote (apostrophe)
       if (separator === "'" && offset > 0) return match;
-      return separator + char.toUpperCase();
+      return separator + whitespace + char.toUpperCase();
     });
   });
   AppPipeRegistry.register('truncate', (value, length = 50, suffix = '...') => {

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,13 +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 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,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);
   }
@@ -68,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({});
+  });
 });