@nutin/cli 1.2.3 → 1.3.0

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

@@ -12,11 +12,21 @@ export interface IRequestConfig {
 }
 
 export class HttpBuilder {
-  static buildRequestBody(data: unknown): string | undefined {
-    return data ? JSON.stringify(data) : undefined;
+  public static buildRequestOptions(
+    method: HttpMethod,
+    data: unknown,
+    config: IRequestConfig,
+    signal: AbortSignal
+  ): RequestInit {
+    return {
+      method,
+      headers: config.headers,
+      body: this.buildRequestBody(data),
+      signal
+    };
   }
 
-  static buildRequestUrl(endpoint: string, queryParams?: Record<string, string>): URL {
+  public static buildRequestUrl(endpoint: string, queryParams?: Record<string, string>): URL {
     const url = new URL(endpoint);
     
     if (queryParams) {
@@ -26,23 +36,13 @@ export class HttpBuilder {
     return url;
   }
 
-  static appendQueryParams(url: URL, queryParams: Record<string, string>): void {
+  private static buildRequestBody(data: unknown): string | undefined {
+    return data ? JSON.stringify(data) : undefined;
+  }
+
+  private static appendQueryParams(url: URL, queryParams: Record<string, string>): void {
     Object.entries(queryParams).forEach(([key, value]) => {
       url.searchParams.append(key, value);
     });
   }
-
-  static buildRequestOptions(
-    method: HttpMethod,
-    data: unknown,
-    config: IRequestConfig,
-    signal: AbortSignal
-  ): RequestInit {
-    return {
-      method,
-      headers: config.headers,
-      body: this.buildRequestBody(data),
-      signal
-    };
-  }
 }

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

@@ -16,7 +16,7 @@ export class HttpError extends Error {
 }
 
 export class HttpManager {
-  static createAbortController(timeout?: number): IAbortControllerSetup {
+  public static createAbortController(timeout?: number): IAbortControllerSetup {
     const controller = new AbortController();
     const timeoutId = timeout ? 
       setTimeout(() => controller.abort(), timeout) : 
@@ -25,25 +25,13 @@ export class HttpManager {
     return { controller, timeoutId };
   }
 
-  static async safeParseErrorResponse(response: Response): Promise<unknown> {
-    try {
-      return await response.json();
-    } catch {
-      return null;
-    }
-  }
-
-  static async validateResponse(response: Response): Promise<void> {
+  public static async validateResponse(response: Response): Promise<void> {
     if (!response.ok) {
       await this.handleResponseError(response);
     }
   }
-
-  static isJsonResponse(contentType: string | null): boolean {
-    return contentType?.includes('application/json') ?? false;
-  }
   
-  static async parseSuccessResponse<T>(response: Response): Promise<T> {
+  public static async parseSuccessResponse<T>(response: Response): Promise<T> {
     const contentType = response.headers.get('content-type');
     
     if (this.isJsonResponse(contentType)) {
@@ -53,25 +41,37 @@ export class HttpManager {
     return await response.text() as unknown as T;
   }
 
-  static isTimeoutError(error: unknown): boolean {
-    return error instanceof DOMException && error.name === 'AbortError';
-  }
-
-  static handleRequestError(error: unknown): never {
+  public static handleRequestError(error: unknown): never {
     if (this.isTimeoutError(error)) {
       throw new Error('Request timed out');
     }
     throw error;
   }
 
-  static async handleResponseError(response: Response): Promise<never> {
+  public static cleanupTimeout(timeoutId: TimeoutType | null): void {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  private static async handleResponseError(response: Response): Promise<never> {
     const errorData = await this.safeParseErrorResponse(response);
     throw new HttpError(response.status, response.statusText, errorData);
   }
 
-  static cleanupTimeout(timeoutId: TimeoutType | null): void {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
+  private static isJsonResponse(contentType: string | null): boolean {
+    return contentType?.includes('application/json') ?? false;
+  }
+
+  private static async safeParseErrorResponse(response: Response): Promise<unknown> {
+    try {
+      return await response.json();
+    } catch {
+      return null;
     }
   }
+
+  private static isTimeoutError(error: unknown): boolean {
+    return error instanceof DOMException && error.name === 'AbortError';
+  }
 }

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

@@ -17,15 +17,31 @@ export class HttpClient extends Service<HttpClient> {
     this._defaultHeaders = { 'Content-Type': 'application/json', ...defaultHeaders };
   }
 
-  public addRequestInterceptor(fn: (url: string, options: RequestInit) => void) {
+  public get<T = unknown>(endpoint: string, config?: IRequestConfig): Promise<T> { 
+    return this.request<T>('GET', endpoint, null, config);
+  }
+  public post<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+    return this.request<T>('POST', endpoint, data, config);
+  }
+  public put<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+    return this.request<T>('PUT', endpoint, data, config);
+  }
+  public patch<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig): Promise<T> { 
+    return this.request<T>('PATCH', endpoint, data, config);
+  }
+  public delete<T = unknown>(endpoint: string, config?: IRequestConfig): Promise<T> { 
+    return this.request<T>('DELETE', endpoint, undefined, config);
+  }
+
+  public addRequestInterceptor(fn: (url: string, options: RequestInit) => void): void {
     this._requestInterceptors.push(fn);
   }
 
-  public addResponseInterceptor(fn: (response: Response) => void) {
+  public addResponseInterceptor(fn: (response: Response) => void): void {
     this._responseInterceptors.push(fn);
   }
 
-  onDestroy(): void {
+  protected onDestroy(): void {
     this._baseUrl = '';
     this._defaultHeaders = {};
     this._requestInterceptors = [];
@@ -60,22 +76,6 @@ export class HttpClient extends Service<HttpClient> {
       HttpManager.cleanupTimeout(timeoutId);
     }
   }
-
-  public get<T = unknown>(endpoint: string, config?: IRequestConfig) { 
-    return this.request<T>('GET', endpoint, null, config);
-  }
-  public post<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig) { 
-    return this.request<T>('POST', endpoint, data, config);
-  }
-  public put<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig) { 
-    return this.request<T>('PUT', endpoint, data, config);
-  }
-  public patch<T = unknown>(endpoint: string, data?: unknown, config?: IRequestConfig) { 
-    return this.request<T>('PATCH', endpoint, data, config);
-  }
-  public delete<T = unknown>(endpoint: string, config?: IRequestConfig) { 
-    return this.request<T>('DELETE', endpoint, undefined, config);
-  }
 }
 
 export const AppHttpClient = HttpClient.getInstance();

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

@@ -7,11 +7,7 @@ class PipeRegistry extends Service<PipeRegistry> {
 
   constructor() { super(); }
 
-  onDestroy() {
-    this._pipes = {};
-  }
-
-  register(name: string, fn: PipeFunction): void {
+  public register(name: string, fn: PipeFunction): void {
     if(this._pipes[name]) {
       console.warn(`Skipping pipe "${name}": A pipe with this name already exists.`);
       return;
@@ -19,7 +15,7 @@ class PipeRegistry extends Service<PipeRegistry> {
     this._pipes[name] = fn;
   }
 
-  apply(name: string, value: any, args: string[] = []): string {
+  public apply(name: string, value: any, args: string[] = []): string {
     const pipe = this._pipes[name];
     if (!pipe) {
       console.warn(`Pipe "${name}" not found.`);
@@ -27,6 +23,10 @@ class PipeRegistry extends Service<PipeRegistry> {
     }
     return pipe(value, ...args);
   }
+
+  protected onDestroy(): void {
+    this._pipes = {};
+  }
 }
 
 export const AppPipeRegistry = PipeRegistry.getInstance();

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

@@ -4,20 +4,12 @@ import { {{#if i18n}}I18nService, {{/if}}View } from "../../../index.js";
  * Navigation - handles path normalization and history management
  */
 export class NavigationManager {
-  static normalizePath(path: string): string {
+  public static normalizePath(path: string): string {
     const url = new URL(path, window.location.origin);
     return (url.pathname || '/').replace(/\/+$/, '') || '/';
   }
 
-  static shouldPushState(
-    pushState: boolean,
-    currentPath: string,
-    normalizedPath: string
-  ): boolean {
-    return pushState && currentPath !== normalizedPath;
-  }
-
-  static updateHistory(
+  public static updateHistory(
     normalizedPath: string,
     currentPath: string,
     pushState: boolean
@@ -27,7 +19,7 @@ export class NavigationManager {
     }
   }
 
-  static updateMetaContent(currentView: View): void {
+  public static updateMetaContent(currentView: View): void {
     if (!currentView.shouldUpdateMetaContent()) return;
 
     const strippedName = currentView.viewName.replace('-view', '');
@@ -44,11 +36,11 @@ export class NavigationManager {
     {{/if}}
   }
 
-  static getCurrentPath(): string {
+  public static getCurrentPath(): string {
     return this.normalizePath(window.location.pathname);
   }
 
-  static matchPattern(pattern: string, path: string): Record<string, string> | null {
+  public static matchPattern(pattern: string, path: string): Record<string, string> | null {
     const paramNames: string[] = [];
 
     const regexPattern = pattern
@@ -75,4 +67,12 @@ 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.ts.hbs

@@ -25,31 +25,11 @@ export type RouteConfig = (() => View) | {
 export type Routes = Record<string, RouteConfig>;
 
 export class RouteGuardsManager {
-  static getViewConstructor(routeConfig: RouteConfig): () => View {
+  public static getViewConstructor(routeConfig: RouteConfig): () => View {
     return typeof routeConfig === 'function' ? routeConfig : routeConfig.view;
   }
 
-  static getRouteGuards(routeConfig: RouteConfig): RouteGuard[] {
-    return typeof routeConfig === 'function' ? [] : (routeConfig.guards || []);
-  }
-
-  /**
-   * Runs all guards in sequence with route parameters and returns the result
-   */
-  static async runGuards(
-    guards: RouteGuard[], 
-    params: Record<string, string>
-  ): Promise<boolean | string> {
-    for (const guard of guards) {
-      const result = await guard(params);
-      if (result !== true) {
-        return result; // false or redirect path
-      }
-    }
-    return true;
-  }
-
-  static async processRouteGuards(
+  public static async processRouteGuards(
     routeConfig: RouteConfig,
     targetPath: string,
     params: Record<string, string> = {}
@@ -71,4 +51,24 @@ export class RouteGuardsManager {
     const viewConstructor = this.getViewConstructor(routeConfig);
     return { allowed: true, viewConstructor };
   }
+
+  private static getRouteGuards(routeConfig: RouteConfig): RouteGuard[] {
+    return typeof routeConfig === 'function' ? [] : (routeConfig.guards || []);
+  }
+
+  /**
+   * Runs all guards in sequence with route parameters and returns the result
+   */
+  private static async runGuards(
+    guards: RouteGuard[], 
+    params: Record<string, string>
+  ): Promise<boolean | string> {
+    for (const guard of guards) {
+      const result = await guard(params);
+      if (result !== true) {
+        return result; // false or redirect path
+      }
+    }
+    return true;
+  }
 }

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

@@ -5,7 +5,7 @@ import { View, AppEventBus } from '../../../index.js';
  */
 export class ViewRenderManager {
   {{#if transition}}
-  static renderAnimatedView(view: View): void {
+  public static renderAnimatedView(view: View): void {
     const container = document.getElementById('app');
     const el = view.render();
     el.classList.add('app-view-transition');
@@ -17,7 +17,7 @@ export class ViewRenderManager {
   }
 
   {{/if}}
-  static async transitionOutCurrentView(currentView: View | null): Promise<null> {
+  public static async transitionOutCurrentView(currentView: View | null): Promise<null> {
     if (!currentView) return null;
     {{#if transition}}
     const container = document.getElementById('app');
@@ -33,7 +33,7 @@ export class ViewRenderManager {
     return null;
   }
 
-  static renderNewView(
+  public static renderNewView(
     viewConstructor: () => View,
     params: Record<string, string> = {}
   ): View {
@@ -49,13 +49,14 @@ export class ViewRenderManager {
     view.render();
 
     {{/if}}
+
     this.cleanupOptionalContent();
 
     this.emitEvent('view-mount', view.viewName);
     return view;
   }
 
-  static cleanupOptionalContent() {
+  public static cleanupOptionalContent(): void {
     const isEmpty = (el: HTMLElement): boolean => {
       const attrName = el.dataset.optional?.trim();
 
@@ -85,7 +86,7 @@ export class ViewRenderManager {
     });
   }
 
-  static emitEvent(event: EventKey, viewName: string): void {
+  private static emitEvent(event: EventKey, viewName: string): void {
     AppEventBus.emit(event, viewName);
   }
   {{#if transition}}

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

@@ -26,6 +26,51 @@ class Router {
     this.navigate(NavigationManager.getCurrentPath());
   }
 
+  public async reload(): Promise<void> {
+    const currentRoute = NavigationManager.getCurrentPath();
+    await this.navigate(currentRoute, false);
+  }
+
+  public async navigate(path: string | '', pushState: boolean = true): Promise<void> {
+    const normalizedPath = NavigationManager.normalizePath(path);
+    const currentPath = NavigationManager.getCurrentPath();
+    
+    // Try to match the route with parameters
+    const routeMatch = this.matchRoute(normalizedPath);
+
+    if (!routeMatch) {
+      await this.handleNotFound(normalizedPath, currentPath, pushState);
+      return;
+    }
+
+    const guardResult = await this.handleGuards(
+      normalizedPath, 
+      routeMatch.route, 
+      routeMatch.params, 
+      pushState
+    );
+    
+    if (!guardResult) return;
+
+    this._currentView = await ViewRenderManager.transitionOutCurrentView(this._currentView);
+    this._currentParams = routeMatch.params;
+    this._currentView = ViewRenderManager.renderNewView(
+      guardResult.viewConstructor!, 
+      routeMatch.params
+    );
+    
+    NavigationManager.updateMetaContent(this._currentView);
+    NavigationManager.updateHistory(normalizedPath, currentPath, pushState);
+  }
+
+  public getCurrentParams(): Record<string, string> {
+    return { ...this._currentParams };
+  }
+
+  public getParam(key: string): string | undefined {
+    return this._currentParams[key];
+  }
+
   private initializeEventListeners(): void {
     window.addEventListener('popstate', () => this.handlePopState());
     AppEventBus.subscribe('navigate', (path: string) => this.navigate(path));
@@ -95,51 +140,6 @@ class Router {
 
     return guardResult;
   }
-
-  public async reload(): Promise<void> {
-    const currentRoute = NavigationManager.getCurrentPath();
-    await this.navigate(currentRoute, false);
-  }
-
-  public async navigate(path: string | '', pushState: boolean = true): Promise<void> {
-    const normalizedPath = NavigationManager.normalizePath(path);
-    const currentPath = NavigationManager.getCurrentPath();
-    
-    // Try to match the route with parameters
-    const routeMatch = this.matchRoute(normalizedPath);
-
-    if (!routeMatch) {
-      await this.handleNotFound(normalizedPath, currentPath, pushState);
-      return;
-    }
-
-    const guardResult = await this.handleGuards(
-      normalizedPath, 
-      routeMatch.route, 
-      routeMatch.params, 
-      pushState
-    );
-    
-    if (!guardResult) return;
-
-    this._currentView = await ViewRenderManager.transitionOutCurrentView(this._currentView);
-    this._currentParams = routeMatch.params;
-    this._currentView = ViewRenderManager.renderNewView(
-      guardResult.viewConstructor!, 
-      routeMatch.params
-    );
-    
-    NavigationManager.updateMetaContent(this._currentView);
-    NavigationManager.updateHistory(normalizedPath, currentPath, pushState);
-  }
-
-  public getCurrentParams(): Record<string, string> {
-    return { ...this._currentParams };
-  }
-
-  public getParam(key: string): string | undefined {
-    return this._currentParams[key];
-  }
 }
 
 export const AppRouter = (routes: Routes) => new Router(routes);

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

@@ -10,10 +10,6 @@ export class Store extends Service<Store> {
     this.registerCleanup(this.clear);
   }
 
-  protected onDestroy(): void {
-    this.clear();
-  }
-
   public set<T = any>(key: string, value: T): void {
     this._state[key] = value;
     AppEventBus.emit(`store:${key}`, value);
@@ -27,12 +23,16 @@ export class Store extends Service<Store> {
     AppEventBus.subscribe(`store:${key}`, callback);
   }
 
+  public unsubscribe<T = any>(key: string, callback: (value: T) => void): void {
+    AppEventBus.off(`store:${key}`, callback);
+  }
+
   public clear(): void {
     this._state = {};
   }
 
-  public unsubscribe<T = any>(key: string, callback: (value: T) => void): void {
-    AppEventBus.off(`store:${key}`, callback);
+  protected onDestroy(): void {
+    this.clear();
   }
 }
 

package/templates/base/src/core/utils/anchor-manager/anchor-manager.utils.ts.hbs

@@ -3,9 +3,9 @@ import { AttributesHelper, IAttributesConfig } from "../helpers/attributes.helpe
 /**
  * ```typescript
 interface IAttributesConfig {
-{{#if i18n}}
+  {{#if i18n}}
   i18nKey?: string;
-{{/if}}
+  {{/if}}
   textContent?: string;
   className?: string;
   style?: string;
@@ -42,8 +42,8 @@ export class AnchorManager {
     target.appendChild(container);
   }
 
-  private createAnchorContainer() {
-    const container = document.createElement('div');
+  private createAnchorContainer(): HTMLSpanElement {
+    const container = document.createElement('span');
     const anchor = this.createAnchor();
 
     container.appendChild(anchor);
@@ -56,16 +56,14 @@ export class AnchorManager {
 
     this.setAnchorRef(anchor);
     
-    AttributesHelper.setContent(anchor, this.config);
-    AttributesHelper.setStyle(anchor, this.config);
-    AttributesHelper.setPipes(anchor, this.config);
+    AttributesHelper.setAttributes(anchor, this.config);
 
     this.handleClick(anchor);
 
     return anchor;
   }
 
-  private setAnchorRef(anchor: HTMLAnchorElement) {
+  private setAnchorRef(anchor: HTMLAnchorElement): void {
     anchor.setAttribute('href', this.config.href);
     if (this.config.target) {
       anchor.setAttribute('target', this.config.target);

package/templates/base/src/core/utils/button-manager/button-manager.utils.ts.hbs

@@ -69,19 +69,24 @@ export class ButtonManager {
     return container;
   }
 
+  public appendTo(target: HTMLElement): void {
+    const container = this.createButtonContainer();
+    if (container) {
+      target.appendChild(container);
+    }
+  }
+
   private createButton(config: BaseButton, index: number): HTMLElement {
     const button = document.createElement('button');
     
-    AttributesHelper.setContent(button, config);
-    AttributesHelper.setStyle(button, config);
-    AttributesHelper.setPipes(button, config);
+    AttributesHelper.setAttributes(button, config);
 
     this.setDataEvent(button, index);
 
     return button;
   }
 
-  private setDataEvent(button: HTMLButtonElement, index: number) {
+  private setDataEvent(button: HTMLButtonElement, index: number): void {
     button.setAttribute('data-event', `click:onButtonClick_${index}`);
   }
 
@@ -95,13 +100,6 @@ export class ButtonManager {
     };
   }
 
-  public appendTo(target: HTMLElement): void {
-    const container = this.createButtonContainer();
-    if (container) {
-      target.appendChild(container);
-    }
-  }
-
 /** Note : doesn't track container
 */
   public updateButtons(newButtons: BaseButton[]): void {

package/templates/base/src/core/utils/helpers/attributes.helper.ts.hbs

@@ -10,21 +10,27 @@ export interface IAttributesConfig {
 }
 
 export class AttributesHelper {
-  static setContent(element: HTMLElement, config: IAttributesConfig) {
+  public static setAttributes(element: HTMLElement, config: IAttributesConfig): void {
+    this.setContent(element, config);
+    this.setPipes(element, config);
+    this.setStyle(element, config);
+  }
+
+  private static setContent(element: HTMLElement, config: IAttributesConfig): void {
     element.textContent = config.textContent || '';
-  {{#if i18n}}
+    {{#if i18n}}
     if (config.i18nKey) {
       element.setAttribute('data-i18n', config.i18nKey);
     }
-  {{/if}}
+    {{/if}}
   }
 
-  static setPipes(element: HTMLElement, config: IAttributesConfig) {
+  private static setPipes(element: HTMLElement, config: IAttributesConfig): void {
     if (!config.pipes) return;
     element.setAttribute('data-pipe', config.pipes);
   }
 
-  static setStyle(element: HTMLElement, config: IAttributesConfig) {    
+  private static setStyle(element: HTMLElement, config: IAttributesConfig): void {    
     const classes = [
       config.className
     ].filter(Boolean).join(' ');

package/templates/base/src/libs/pipes/pipes.ts.hbs

@@ -1,6 +1,6 @@
 import { AppPipeRegistry } from "../../core/index.js";
 
-export const registerPipes = () => {    
+export const registerPipes = (): void => {    
   // currency
   AppPipeRegistry.register('currency', (
     value: number,