@nutin/cli 1.3.1 → 2.1.0

package/templates/base/src/core/services/http-client/http-client.test.js.hbs

@@ -197,13 +197,84 @@ describe('HttpClient', () => {
 
   it('should handle custom headers', async () => {
     fetchMock.mockJsonResponse('https://api.example.com/users', []);
-    
+
     await httpClient.get('https://api.example.com/users', { headers: { 'Authorization': 'Bearer custom-token' } });
-    
+
     const lastCall = fetchMock.getLastCall();
     expect(lastCall.options.headers['Authorization']).toBe('Bearer custom-token');
   });
 
+  it('should send the constructor default headers on a request with no custom headers', async () => {
+    fetchMock.mockJsonResponse('https://api.example.com/users', []);
+
+    await httpClient.get('https://api.example.com/users');
+
+    const lastCall = fetchMock.getLastCall();
+    expect(lastCall.options.headers['Content-Type']).toBe('application/json');
+  });
+
+  it('should merge default headers with per-call headers on different keys', async () => {
+    fetchMock.mockJsonResponse('https://api.example.com/users', []);
+
+    await httpClient.get('https://api.example.com/users', { headers: { 'Authorization': 'Bearer custom-token' } });
+
+    const lastCall = fetchMock.getLastCall();
+    expect(lastCall.options.headers['Content-Type']).toBe('application/json');
+    expect(lastCall.options.headers['Authorization']).toBe('Bearer custom-token');
+  });
+
+  it('should let a per-call header override a default header on the same key', async () => {
+    fetchMock.mockJsonResponse('https://api.example.com/users', []);
+
+    await httpClient.get('https://api.example.com/users', { headers: { 'Content-Type': 'text/plain' } });
+
+    const lastCall = fetchMock.getLastCall();
+    expect(lastCall.options.headers['Content-Type']).toBe('text/plain');
+  });
+
+  it('should invoke request interceptors with the final url and options before sending', async () => {
+    fetchMock.mockJsonResponse('https://api.example.com/users', []);
+    const calls = [];
+    httpClient.addRequestInterceptor((url, options) => calls.push({ url, options }));
+
+    await httpClient.get('https://api.example.com/users');
+
+    expect(calls.length).toBe(1);
+    expect(calls[0].url).toBe('https://api.example.com/users');
+    expect(calls[0].options.method).toBe('GET');
+  });
+
+  it('should invoke response interceptors with the raw fetch response', async () => {
+    fetchMock.mockJsonResponse('https://api.example.com/users', []);
+    const received = [];
+    httpClient.addResponseInterceptor((response) => received.push(response));
+
+    await httpClient.get('https://api.example.com/users');
+
+    expect(received.length).toBe(1);
+    expect(received[0].ok).toBe(true);
+  });
+
+  it('should propagate a non-timeout error thrown while parsing the response', async () => {
+    fetchMock.mockResponse('https://api.example.com/broken', {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: { get: () => 'application/json' },
+      json: () => Promise.reject(new Error('Malformed JSON')),
+      text: () => Promise.resolve('not json'),
+    });
+
+    let thrown = false;
+    try {
+      await httpClient.get('https://api.example.com/broken');
+    } catch (error) {
+      thrown = true;
+      expect(error.message).toBe('Malformed JSON');
+    }
+    expect(thrown).toBe(true);
+  });
+
   it('should handle HTTP errors', async () => {
     fetchMock.mockError('https://api.example.com/users', 404, { message: 'Not found' });
         

package/templates/base/src/core/services/http-client/http-client.ts.hbs

@@ -56,7 +56,10 @@ export class HttpClient extends Service<HttpClient> {
   ): Promise<T> {
     const { controller, timeoutId } = HttpManager.createAbortController(config?.timeout);
     const fullUrl = `${this._baseUrl}${endpoint}`;
-    const mergedConfig = { ...this._defaultHeaders, ...config };
+    const mergedConfig: IRequestConfig = {
+      ...config,
+      headers: { ...this._defaultHeaders, ...config?.headers },
+    };
 
     try {
       const url = HttpBuilder.buildRequestUrl(fullUrl, config?.queryParams);

package/templates/base/src/core/services/i18n/i18n.test.js.hbs

@@ -0,0 +1,270 @@
+import { I18nService, AppEventBus } from '#root/dist/src/core/services/index.js';
+import { CONFIG } from '#root/dist/src/core/config.js';
+
+class FetchMock {
+  constructor() {
+    this.originalFetch = global.fetch;
+    this.mockResponses = new Map();
+  }
+  
+  mockTranslation(lang, data) {
+    this.mockResponses.set(`/locales/${lang}.json`, {
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve(data)
+    });
+    return this;
+  }
+
+  mockError(url, status = 404) {
+    this.mockResponses.set(url, {
+      ok: false,
+      status,
+      json: () => Promise.reject(new Error(`HTTP ${status}`))
+    });
+    return this;
+  }
+  
+  install() {
+    global.fetch = (url) => {      
+      if (this.mockResponses.has(url)) {
+        const response = this.mockResponses.get(url);
+        return Promise.resolve(response);
+      }
+
+      return this.originalFetch ? this.originalFetch(url) : Promise.reject(new Error('fetch not available'));
+    };
+    return this;
+  }
+  
+  restore() {
+    global.fetch = this.originalFetch;
+    this.mockResponses.clear();
+  }
+}
+
+const fetchMock = new FetchMock();
+
+describe('i18n module', async () => {
+  let originalLanguage;
+
+  beforeEach(async () => {
+    I18nService.resetTranslations();
+    fetchMock
+      .mockTranslation('en', { home: { title : 'My App', subtitle: "English subtitle" }})
+      .mockTranslation('fr', { home: { title : 'Mon App' }})
+      .install();
+  });
+  afterEach(() => {
+    fetchMock.restore();
+    localStorage.removeItem(I18nService.localStorageKey)
+  });
+
+  beforeAll(() =>{
+    originalLanguage = navigator.language;    
+    Object.defineProperty(navigator, 'language', {
+      writable: true,
+      configurable: true,
+      value: "en-US"
+    });
+    I18nService['_LANGUAGES'] = [ 'en', 'fr' ];
+    I18nService['_DEFAULT_LANGUAGE'] = 'en';
+  });
+  afterAll(() => {    
+    Object.defineProperty(navigator, 'language', {
+      writable: true,
+      configurable: true,
+      value: originalLanguage
+    });
+  });
+
+  it('should load and use English translations', async () => {
+    await I18nService.initTranslations();
+    expect(I18nService.currentLanguage).toBe('en');
+    expect(I18nService.translate('home.title')).toBe('My App');
+  });
+
+  it('should load and use French translations', async () => {
+    Object.defineProperty(navigator, 'language', {
+      writable: true,
+      configurable: true,
+      value: "fr-FR"
+    });
+    await I18nService.initTranslations();
+    expect(I18nService.currentLanguage).toBe('fr');
+    expect(I18nService.translate('home.title')).toBe('Mon App');
+  });
+
+  it('should default to English translations', async () => {
+    // missing locale
+    Object.defineProperty(navigator, 'language', {
+      writable: true,
+      configurable: true,
+      value: "de-DE"
+    });
+    await I18nService.initTranslations();
+    expect(navigator.language).toBe('de-DE');
+    expect(I18nService.currentLanguage).toBe('en');
+    expect(I18nService.translate('home.title')).toBe('My App');
+    I18nService.resetTranslations();
+
+    // missing translation
+    Object.defineProperty(navigator, 'language', {
+      writable: true,
+      configurable: true,
+      value: "fr-FR"
+    });
+    await I18nService.initTranslations();
+    expect(navigator.language).toBe('fr-FR');
+    expect(I18nService.currentLanguage).toBe('fr');
+    expect(I18nService.translate('home.title')).toBe('Mon App');
+    expect(I18nService.translate('home.subtitle')).toBe('English subtitle');
+  });
+
+  it('should return key when translation is missing', () => {
+    expect(I18nService.translate('non.existent.key')).toBe('non.existent.key');
+  });
+
+  it('setCurrentLanguage updates the language, persists it and loads its translations', async () => {
+    await I18nService.setCurrentLanguage('fr');
+
+    expect(I18nService.currentLanguage).toBe('fr');
+    expect(I18nService.translate('home.title')).toBe('Mon App');
+    expect(localStorage.getItem(I18nService.localStorageKey)).toBe('fr');
+  });
+
+  it('setCurrentLanguage emits a language-changed event with the new language', async () => {
+    const received = [];
+    const callback = (data) => received.push(data);
+    I18nService.onLanguageChange(callback);
+
+    await I18nService.setCurrentLanguage('fr');
+
+    expect(received).toEqual([{ lang: 'fr' }]);
+    AppEventBus.off('language-changed', callback);
+  });
+
+  it('getTranslationObject returns the nested value for the current language', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
+    await I18nService.initTranslations();
+    expect(I18nService.getTranslationObject('home')).toEqual({ title: 'My App', subtitle: 'English subtitle' });
+  });
+
+  it('getTranslationObject falls back to the default language when missing in the current language', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'fr-FR' });
+    await I18nService.initTranslations();
+    expect(I18nService.getTranslationObject('home.subtitle')).toBe('English subtitle');
+  });
+
+  it('getTranslationObject returns null when the key is not found anywhere', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
+    await I18nService.initTranslations();
+    expect(I18nService.getTranslationObject('does.not.exist')).toBe(null);
+  });
+
+  it('honors a locale prefix in the URL path when CONFIG.i18n is enabled', async () => {
+    CONFIG.i18n = true;
+    window.history.pushState({}, '', '/fr/some/page');
+    try {
+      await I18nService.initTranslations();
+      expect(I18nService.currentLanguage).toBe('fr');
+    } finally {
+      CONFIG.i18n = false;
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('ignores a locale prefix in the URL path when CONFIG.i18n is disabled (default)', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
+    window.history.pushState({}, '', '/fr/some/page');
+    try {
+      await I18nService.initTranslations();
+      expect(I18nService.currentLanguage).toBe('en');
+    } finally {
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('initTranslations falls back to the default language when the resolved preferred language is unsupported', async () => {
+    const original = I18nService.getPreferredLanguage;
+    I18nService.getPreferredLanguage = () => 'zz';
+    try {
+      await I18nService.initTranslations();
+      expect(I18nService.currentLanguage).toBe('en');
+    } finally {
+      I18nService.getPreferredLanguage = original;
+    }
+  });
+
+  it('getLocaleFromUrl returns null when the URL locale segment is not supported', () => {
+    CONFIG.i18n = true;
+    window.history.pushState({}, '', '/xx/page');
+    try {
+      expect(I18nService.getLocaleFromUrl()).toBe(null);
+    } finally {
+      CONFIG.i18n = false;
+      window.history.pushState({}, '', '/');
+    }
+  });
+
+  it('loadDefaultTranslations logs and leaves default translations empty when the fetch fails', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'fr-FR' });
+    const errSpy = spyOn(console, 'error');
+    errSpy.andCallFake(() => {});
+    fetchMock.mockError('/locales/en.json', 500);
+
+    await I18nService.initTranslations();
+
+    // loadDefaultTranslations is attempted twice: once explicitly by initTranslations,
+    // and again from within loadTranslations('fr') since _defaultTranslations is still
+    // empty after the first failure — each attempt logs its own error.
+    expect(errSpy.callCount).toBe(2);
+    expect(I18nService.currentLanguage).toBe('fr');
+
+    errSpy.restore();
+  });
+
+  it('honors a previously saved language preference from localStorage', async () => {
+    localStorage.setItem(I18nService.localStorageKey, 'fr');
+    await I18nService.initTranslations();
+    expect(I18nService.currentLanguage).toBe('fr');
+  });
+
+  it('loadTranslations logs and leaves the language unchanged when the fetch rejects', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
+    const errSpy = spyOn(console, 'error');
+    errSpy.andCallFake(() => {});
+    global.fetch = () => Promise.reject(new Error('network down'));
+
+    await I18nService.initTranslations();
+
+    expect(errSpy.callCount).toBe(1);
+    expect(I18nService.currentLanguage).toBe('en');
+
+    errSpy.restore();
+  });
+
+  it('loadTranslations logs and leaves state unchanged when the response is not ok', async () => {
+    Object.defineProperty(navigator, 'language', { writable: true, configurable: true, value: 'en-US' });
+    const errSpy = spyOn(console, 'error');
+    errSpy.andCallFake(() => {});
+    fetchMock.mockError('/locales/en.json', 500);
+
+    await I18nService.initTranslations();
+
+    expect(errSpy.callCount).toBe(1);
+    expect(I18nService.currentLanguage).toBe('en');
+
+    errSpy.restore();
+  });
+
+  it('onDestroy resets translations and disposes the instance', async () => {
+    await I18nService.initTranslations();
+    expect(I18nService.translate('home.title')).toBe('My App');
+
+    I18nService.onDestroy();
+
+    expect(I18nService.translate('home.title')).toBe('home.title');
+    expect(localStorage.getItem(I18nService.localStorageKey)).toBe(null);
+  });
+});

package/templates/{features/i18n → base}/src/core/services/i18n/i18n.ts.hbs

@@ -1,5 +1,6 @@
 import { DEFAULT_LANGUAGE, LANGUAGES, Language, Translations } from './languages.js';
 import { AppEventBus, Service } from '../../index.js';
+import { CONFIG } from '../../config.js';
 
 export class I18n extends Service<I18n> {
   private readonly _DEFAULT_LANGUAGE: Language = DEFAULT_LANGUAGE;
@@ -35,7 +36,11 @@ export class I18n extends Service<I18n> {
     this._currentLanguage = lang;
     this.savePreferences();
     await this.loadTranslations(lang);
-    AppEventBus.emit('language-changed');
+    AppEventBus.emit('language-changed', { lang });
+  }
+
+  public onLanguageChange(callback: (payload: { lang: string }) => void) {
+    AppEventBus.subscribe('language-changed', callback);
   }
 
   public async loadTranslations(lang: Language): Promise<void> {
@@ -99,6 +104,7 @@ export class I18n extends Service<I18n> {
   public resetTranslations(): void {
     this._translations = {};
     this._defaultTranslations = {};
+    localStorage.removeItem(this._localStorageKey);
     this._currentLanguage = this._DEFAULT_LANGUAGE;
   }
 
@@ -107,9 +113,21 @@ export class I18n extends Service<I18n> {
     this.dispose();
   }
 
-  private getPreferredLanguage() {
-    return this.getPreferences() || navigator.language.split('-')[0] as Language;
-  };
+  private getPreferredLanguage(): Language {
+    const urlLocale = this.getLocaleFromUrl();
+    if (urlLocale) return urlLocale;
+    const stored = this.getPreferences();
+    if (stored && this._LANGUAGES.includes(stored as Language)) return stored as Language;
+    const browserLang = navigator.language.split('-')[0] as Language;
+    return this._LANGUAGES.includes(browserLang) ? browserLang : this._DEFAULT_LANGUAGE;
+  }
+
+  private getLocaleFromUrl(): Language | null {
+    if (!CONFIG.i18n) return null;
+
+    const first = window.location.pathname.split('/').filter(Boolean)[0] as Language;
+    return first && this._LANGUAGES.includes(first) ? first : null;
+  }
 
   private async loadDefaultTranslations(): Promise<void> {
     try {

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 = '...') => {