@nutin/cli 1.3.0 → 2.0.0

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

@@ -1,39 +0,0 @@
-import { Service, AppEventBus } from "../../index.js";
-
-export type StoreState = Record<string, any>;
-
-export class Store extends Service<Store> {
-  private _state: StoreState = {};
-
-  constructor() {
-    super();
-    this.registerCleanup(this.clear);
-  }
-
-  public set<T = any>(key: string, value: T): void {
-    this._state[key] = value;
-    AppEventBus.emit(`store:${key}`, value);
-  }
-
-  public get<T = any>(key: string): T | undefined {
-    return this._state[key];
-  }
-
-  public subscribe<T = any>(key: string, callback: (value: T) => void): void {
-    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 = {};
-  }
-
-  protected onDestroy(): void {
-    this.clear();
-  }
-}
-
-export const AppStore = Store.getInstance();

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

@@ -1,85 +0,0 @@
-import { AttributesHelper, IAttributesConfig } from "../helpers/attributes.helper.js";
-
-/**
- * ```typescript
-interface IAttributesConfig {
-  {{#if i18n}}
-  i18nKey?: string;
-  {{/if}}
-  textContent?: string;
-  className?: string;
-  style?: string;
-// use regular pipe syntax for arguments / chaining
-  pipes?: string;
-}
-interface IAnchorConfig extends IAttributesConfig {
-// prefix href with '#' for internal anchor
-  href: string;
-  target?: string;
-  tagName?: keyof HTMLElementTagNameMap;
-}
-```
-*/
-export interface IAnchorConfig extends IAttributesConfig {
-  href: string;
-  target?: string;
-  tagName?: keyof HTMLElementTagNameMap;
-}
-
-export class AnchorManager {
-  private config: IAnchorConfig;
-
-  constructor(
-    config: IAnchorConfig,
-    target: HTMLElement
-  ) {
-    this.config = config;
-    this.appendAnchorElement(target);
-  }
-
-  private appendAnchorElement(target: HTMLElement): void {
-    const container = this.createAnchorContainer();
-    target.appendChild(container);
-  }
-
-  private createAnchorContainer(): HTMLSpanElement {
-    const container = document.createElement('span');
-    const anchor = this.createAnchor();
-
-    container.appendChild(anchor);
-
-    return container;
-  }
-
-  private createAnchor(): HTMLElement {
-    const anchor = document.createElement('a');
-
-    this.setAnchorRef(anchor);
-    
-    AttributesHelper.setAttributes(anchor, this.config);
-
-    this.handleClick(anchor);
-
-    return anchor;
-  }
-
-  private setAnchorRef(anchor: HTMLAnchorElement): void {
-    anchor.setAttribute('href', this.config.href);
-    if (this.config.target) {
-      anchor.setAttribute('target', this.config.target);
-    }
-  }
-
-  private handleClick(anchor: HTMLAnchorElement): void {
-    const isInternal = this.config.href.startsWith('#');
-    if (!isInternal) return;
-
-    const id = this.config.href.slice(1);
-
-    anchor?.addEventListener('click', (e) => {
-      e.preventDefault();
-      const target = document.getElementById(id);
-      target?.scrollIntoView({ behavior: 'smooth' });
-    });
-  }
-}

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

@@ -1,249 +0,0 @@
-import { ButtonManager } from '#root/dist/src/core/index.js';
-
-describe('ButtonManager', () => {
-  it('should initialize with default options', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    
-    expect(manager.component).toBe(mockComponent);
-    expect(manager.buttons.length).toBe(0);
-    expect(manager.containerOptions.containerClassName).toBe('dynamic-buttons');
-  });
-
-  it('should initialize with custom options', () => {
-    const mockComponent = {};
-    const buttons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test' }];
-    const options = { 
-      containerClassName: 'custom-container',
-      buttonClassName: 'custom-button'
-    };
-    
-    const manager = new ButtonManager(mockComponent, buttons, options);
-    
-    expect(manager.buttons.length).toBe(1);
-    expect(manager.containerOptions.containerClassName).toBe('custom-container');
-    expect(manager.containerOptions.buttonClassName).toBe('custom-button');
-  });
-
-  it('should return null for empty buttons array', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent, []);
-    
-    const container = manager.createButtonContainer();
-    expect(container).toBeUndefined();
-  });
-
-  it('should return null for undefined buttons', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    
-    const container = manager.createButtonContainer();
-    expect(container).toBeUndefined();
-  });
-
-  it('should create container with correct class name', () => {
-    const mockComponent = {};
-    const buttons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test' }];
-    const manager = new ButtonManager(mockComponent, buttons);
-    
-    const container = manager.createButtonContainer();
-    
-    expect(container).toBeDefined();
-    expect(container.className).toBe('dynamic-buttons');
-  });
-
-  it('should create container with custom class name', () => {
-    const mockComponent = {};
-    const buttons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test' }];
-    const options = { containerClassName: 'my-buttons' };
-    const manager = new ButtonManager(mockComponent, buttons, options);
-    
-    const container = manager.createButtonContainer();
-    
-    expect(container.className).toBe('my-buttons');
-  });
-
-  it('should create correct number of buttons', () => {
-    const mockComponent = {};
-    const buttons = [
-      { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'button1' },
-      { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'button2' },
-      { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'button3' }
-    ];
-    const manager = new ButtonManager(mockComponent, buttons);
-    
-    const container = manager.createButtonContainer();
-    
-    expect(container.children.length).toBe(3);
-  });
-
-  it('should create button with {{#if i18n}}i18nKey{{else}}textContent{{/if}} as text', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    const btn = { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'save' };
-    
-    const button = manager.createButton(btn, 0);
-    
-    {{#if i18n}}
-    expect(button.getAttribute('data-i18n')).toBe('save');
-    {{else}}
-    expect(button.textContent).toBe('save');
-    {{/if}}
-  });
-{{#if i18n}}
-
-  it('should prioritize textContent over i18nKey', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    const btn = { 
-      i18nKey: 'save',
-      textContent: 'Save Document'
-    };
-    
-    const button = manager.createButton(btn, 0);
-    
-    expect(button.textContent).toBe('Save Document');
-    expect(button.getAttribute('data-i18n')).toBe('save');
-  });
-{{/if}}
-
-  it('should set button className correctly', () => {
-    const mockComponent = {};    
-    const manager = new ButtonManager(mockComponent, []);
-    const btn = { 
-      i18nKey: 'save',
-      className: 'btn-primary'
-    };
-    
-    const button = manager.createButton(btn, 0);
-    
-    expect(button.className).toBe('btn-primary');
-  });
-
-  it('should set data-event attribute correctly', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    const btn = { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'save' };
-    
-    const button = manager.createButton(btn, 2);
-    
-    expect(button.getAttribute('data-event')).toBe('click:onButtonClick_2');
-  });
-
-  it('should bind callback method to component', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    const btn = { 
-      {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test',
-      callback: () => 'called'
-    };
-    
-    manager.bindButtonCallback(btn, 1);
-    
-    expect(typeof mockComponent.onButtonClick_1).toBe('function')
-  });
-
-  it('should execute callback when bound method is called', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    let callbackExecuted = false;
-    const btn = { 
-      {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test',
-      callback: () => { callbackExecuted = true; }
-    };
-    
-    manager.bindButtonCallback(btn, 0);
-    mockComponent.onButtonClick_0();
-    
-    expect(callbackExecuted).toBe(true);
-  });
-
-  it('should append button container to target element', () => {
-    const mockComponent = {};
-    const buttons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'test' }];
-    const manager = new ButtonManager(mockComponent, buttons);
-    const target = document.createElement('div');
-    
-    manager.appendTo(target);
-    
-    expect(target.children.length).toBe(1);
-    expect(target.children[0].className).toBe('dynamic-buttons')
-  });
-
-  it('should not append anything for empty buttons', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent, []);
-    const target = document.createElement('div');
-    
-    manager.appendTo(target);
-    
-    expect(target.children.length).toBe(0);
-  });
-
-  it('should create complete button setup end-to-end', () => {
-    const mockComponent = {};
-    let button1Clicked = false;
-    let button2Clicked = false;
-    
-    const buttons = [
-      {
-        {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'save',
-        className: 'btn-primary',
-        callback: () => { button1Clicked = true; }
-      },
-      {
-        {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'cancel',
-        textContent: 'Cancel Action',
-        className: 'btn-secondary',
-        callback: () => { button2Clicked = true; }
-      }
-    ];
-    
-    const manager = new ButtonManager(mockComponent, buttons, {
-      containerClassName: 'form-buttons'
-    });
-    
-    const container = manager.createButtonContainer();
-    
-    expect(container.className).toBe('form-buttons');
-    expect(container.children.length).toBe(2);
-    
-    const firstButton = container.children[0];
-    expect(firstButton.className).toBe('btn-primary');
-    expect(firstButton.getAttribute('data-event')).toBe('click:onButtonClick_0');
-
-    const secondButton = container.children[1];
-    expect(secondButton.className).toBe('btn-secondary');
-    expect(secondButton.getAttribute('data-event')).toBe('click:onButtonClick_1');
-
-    mockComponent.onButtonClick_0();
-    mockComponent.onButtonClick_1();
-    
-    expect(button1Clicked).toBe(true);
-    expect(button2Clicked).toBe(true);
-  });
-
-  it('should handle button with empty {{#if i18n}}i18nKey{{else}}textContent{{/if}}', () => {
-    const mockComponent = {};
-    const manager = new ButtonManager(mockComponent);
-    const btn = { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: '' };
-    
-    const button = manager.createButton(btn, 0);
-    
-    expect(button.textContent).toBe('');
-    expect(button.getAttribute('data-i18n')).toBe(null);
-  });
-
-  it('should handle updateButtons method', () => {
-    const mockComponent = {};
-    const initialButtons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'initial' }];
-    const manager = new ButtonManager(mockComponent, initialButtons);
-    
-    const newButtons = [{ {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'new1' }, { {{#if i18n}}i18nKey{{else}}textContent{{/if}}: 'new2' }];
-    manager.updateButtons(newButtons);
-    
-    expect(manager.buttons.length).toBe(2);
-    expect(manager.buttons[0].{{#if i18n}}i18nKey{{else}}textContent{{/if}}).toBe('new1');
-    expect(manager.buttons[1].{{#if i18n}}i18nKey{{else}}textContent{{/if}}).toBe('new2');
-  });
-})

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

@@ -1,108 +0,0 @@
-import { AttributesHelper, IAttributesConfig } from "../helpers/attributes.helper.js";
-
-export interface BaseButton extends IAttributesConfig {
-  callback: () => void;
-}
-
-export interface ButtonContainerOptions {
-  containerClassName?: string;
-  containerStyles?: string;
-}
-
-/**
- * ```typescript
- interface IAttributesConfig {
-  {{#if i18n}}
-  i18nKey?: string;
-  {{/if}}
-  textContent?: string;
-  className?: string;
-  style?: string;
-// use regular pipe syntax for arguments / chaining
-  pipes?: string;
-}
-
-interface BaseButton extends IAttributesConfig {
-  callback: () => void;
-}
-
-interface ButtonContainerOptions {
-  containerClassName?: string;
-  containerStyles?: string;
-}
-  ```
-*/
-export class ButtonManager {
-  private component: any;
-  private buttons: BaseButton[];
-  private containerOptions: ButtonContainerOptions;
-
-  constructor(
-    component: any, 
-    buttons: BaseButton[] = [], 
-    containerOptions: ButtonContainerOptions = {}
-  ) {
-    this.component = component;
-    this.buttons = buttons;
-    this.containerOptions = {
-      containerClassName: 'dynamic-buttons',
-      containerStyles: '',
-      ...containerOptions
-    };
-  }
-
-  public createButtonContainer(): HTMLElement | null {
-    if (!Array.isArray(this.buttons) || this.buttons.length === 0) {
-      return null;
-    }
-
-    const container = document.createElement('div');
-    container.className = this.containerOptions.containerClassName || 'dynamic-buttons';
-    container.style = this.containerOptions.containerStyles || '';
-
-    this.buttons.forEach((config, index) => {
-      const button = this.createButton(config, index);
-      container.appendChild(button);
-      this.bindButtonCallback(config, index);
-    });
-
-    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.setAttributes(button, config);
-
-    this.setDataEvent(button, index);
-
-    return button;
-  }
-
-  private setDataEvent(button: HTMLButtonElement, index: number): void {
-    button.setAttribute('data-event', `click:onButtonClick_${index}`);
-  }
-
-  private bindButtonCallback(config: BaseButton, index: number): void {
-    const methodName = `onButtonClick_${index}`;
-    
-    this.component[methodName] = () => {
-      if (typeof config.callback === 'function') {
-        config.callback();
-      }
-    };
-  }
-
-/** Note : doesn't track container
-*/
-  public updateButtons(newButtons: BaseButton[]): void {
-    this.buttons = newButtons;
-  }
-}

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

@@ -1,50 +0,0 @@
-export interface IAttributesConfig {
-  {{#if i18n}}
-  i18nKey?: string;
-  {{/if}}
-  textContent?: string;
-  className?: string;
-  style?: string;
-// use regular pipe syntax for arguments / chaining
-  pipes?: string;
-}
-
-export class AttributesHelper {
-  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 (config.i18nKey) {
-      element.setAttribute('data-i18n', config.i18nKey);
-    }
-    {{/if}}
-  }
-
-  private static setPipes(element: HTMLElement, config: IAttributesConfig): void {
-    if (!config.pipes) return;
-    element.setAttribute('data-pipe', config.pipes);
-  }
-
-  private static setStyle(element: HTMLElement, config: IAttributesConfig): void {    
-    const classes = [
-      config.className
-    ].filter(Boolean).join(' ');
-
-    const style = [
-      config.style
-    ].filter(Boolean).join(' ');
-    
-    if (classes) {
-      element.className = classes;
-    }
-
-    if(style) {
-      element.style = style;
-    }
-  }
-}

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

@@ -1,2 +0,0 @@
-export * from './button-manager/button-manager.utils.js';
-export * from './anchor-manager/anchor-manager.utils.js';

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

@@ -1,4 +0,0 @@
-export * from './snackbar/snackbar.js';
-export * from './popover/popover.js';
-export * from './guards/guards.js';
-export * from './pipes/pipes.js';

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

@@ -1,145 +0,0 @@
-import { View, ButtonManager, BaseButton, ViewRenderManager } from '../../core/index.js';
-
-export interface PopoverButton extends BaseButton {
-  // if needed for Popover-specific properties
-}
-
-export interface PopoverOptions {
-  template: string;
-  viewName?: string;
-  onClose?: () => void;
-  buttons?: PopoverButton[];
-}
-
-export class PopoverView extends View {
-  private onClose?: () => void;
-  private overlay: HTMLElement | null = null;
-  private buttonManager: ButtonManager;
-
-  constructor({
-    template,
-    buttons = [],
-    onClose,
-    viewName = 'popover',
-  }: PopoverOptions) {
-    super({template, tagName: 'div', mountTarget: 'body', viewName});
-    this.onClose = onClose;
-    this.buttonManager = new ButtonManager(
-      this, 
-      this.wrapButtonCallbacks(buttons), 
-      { containerClassName: 'popover-buttons' }
-    );
-  }
-
-  public override shouldUpdateMetaContent(): boolean {
-    return false;
-  }
-
-  public override render(): HTMLElement {
-    document.body.classList.add('no-scroll');
-    this.overlay = this.createOverlay();
-
-    const wrapper = this.createWrapper();
-    const content = this.createContent();
-
-    this.appendCloseButton(content);
-    this.appendFooterButtons(content);
-
-    wrapper.appendChild(content);
-    this.overlay.appendChild(wrapper);
-    document.body.appendChild(this.overlay);
-
-    this.autoBindEvents();
-    this.parseDataAttributes();
-    this.animateIn(wrapper);
-
-    this.bindOverlayClose();
-
-    return this.overlay;
-  }
-
-  public override destroy(): void {
-    if (this.overlay) {
-      const wrapper = this.overlay.querySelector('.popover-wrapper');
-      this.overlay.classList.remove('show');
-      wrapper?.classList.remove('show');
-
-      setTimeout(() => {
-        wrapper?.remove()
-        this.overlay?.remove();
-        this.overlay = null;
-      }, 250); // match transition duration
-    }
-
-    document.body.classList.remove('no-scroll');
-    super.destroy();
-
-    if (typeof this.onClose === 'function') {
-      this.onClose();
-    }
-  }
-
-// Wraps button callbacks to include destroy() call
-  private wrapButtonCallbacks(buttons: PopoverButton[]): PopoverButton[] {
-    return buttons.map(btn => ({
-      ...btn,
-      callback: () => {
-        if (btn.callback) {
-          btn.callback();
-        }
-        this.destroy();
-      }
-    }));
-  }
-
-  private createOverlay(): HTMLElement {
-    const overlay = document.createElement('div');
-    overlay.className = 'popover-overlay';
-    return overlay;
-  }
-
-  private createWrapper(): HTMLElement {
-    const wrapper = document.createElement('div');
-    wrapper.className = 'popover-wrapper';
-    return wrapper;
-  }
-
-  private createContent(): HTMLElement {
-    const content = super.render();
-    content.classList.add('popover-content');
-    ViewRenderManager.cleanupOptionalContent();
-    return content;
-  }
-
-  private appendCloseButton(content: HTMLElement): void {
-    const closeButton = document.createElement('button');
-    closeButton.className = 'popover-close-button';
-    closeButton.innerHTML = '×';
-    closeButton.setAttribute('aria-label', 'Close');
-    // bind method onCloseClick
-    closeButton.setAttribute('data-event', 'click:onCloseClick');
-    content.prepend(closeButton);
-  }
-
-  // Handles the close button (via data-event bound in appendCloseButton)
-  private onCloseClick(): void {
-    this.destroy();
-  }
-
-  private appendFooterButtons(content: HTMLElement): void {
-    this.buttonManager.appendTo(content);
-  }
-
-  private bindOverlayClose(): void {
-    this.overlay?.addEventListener('click', (e: MouseEvent) => {
-      if (e.target === this.overlay) this.destroy();
-    });
-  }
-
-  private animateIn(wrapper: HTMLElement): void {
-    requestAnimationFrame(() => {
-      this.overlay?.classList.add('show');
-      wrapper.classList.add('show');
-    });
-  }
-}