@nutin/cli 1.3.1 → 2.0.0

package/lib/src/print.mjs

@@ -1,32 +0,0 @@
-export const chalk = {
-  green: (s) => `\x1b[32m${s}\x1b[0m`,
-  red: (s) => `\x1b[31m${s}\x1b[0m`,
-  blue: (s) => `\x1b[34m${s}\x1b[0m`,
-  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-  purple: (s) => `\x1b[35m${s}\x1b[0m`,
-  gray: (s) => `\x1b[90m${s}\x1b[0m`,
-  boldGreen: (s) => `\x1b[1;32m${s}\x1b[0m`,
-  boldRed: (s) => `\x1b[1;31m${s}\x1b[0m`,
-  boldBlue: (s) => `\x1b[1;34m${s}\x1b[0m`,
-  boldYellow: (s) => `\x1b[1;33m${s}\x1b[0m`,
-  boldCyan: (s) => `\x1b[1;36m${s}\x1b[0m`,
-  boldPurple: (s) => `\x1b[1;35m${s}\x1b[0m`,
-  boldGray: (s) => `\x1b[1;90m${s}\x1b[0m`,
-};
-
-export const print = {
-	head: (s) => console.log(`${chalk.purple(s)}`),  
-	boldHead : (s) => console.log(`${chalk.boldPurple(s)}`),
-	section: (s) => console.log(`${chalk.yellow(s)}`),
-	boldSection: (s) => console.log(`${chalk.boldYellow(s)}`),
-	info: (s) => console.log(`${chalk.green(s)}`),
-  boldInfo: (s) => console.log(`${chalk.boldGreen(s)}`),
-	success: (s) => console.log(`${chalk.cyan(s)}`),
-	boldSuccess: (s) => console.log(`${chalk.boldCyan(s)}`),
-	error: (s) => console.error(`${chalk.red(s)}`),
-	boldError: (s) => console.error(`${chalk.boldRed(s)}`),
-  grayError: (s) => console.error(`${chalk.gray(s)}`),
-  blue: (s) => console.log(`${chalk.blue(s)}`),
-  boldBlue: (s) => console.log(`${chalk.boldBlue(s)}`),
-}

package/lib/src/utils.mjs

@@ -1,18 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { print } from './print.mjs';
-
-export const promiseExec = promisify(exec);
-
-export function displaySuccessMessage(answers) {
-  const { projectName, packageManager, deployHelper } = answers;
-  print.boldSuccess('\n🎉 Your project is ready!');
-  print.boldInfo(`Documentation on https://www.nutin.org`);
-
-  if (packageManager === 'pnpm' || packageManager === 'bun') {
-    if (deployHelper) print.boldError(`You'll need to modify the Dockerfile to support ${packageManager}`)
-  }
-
-  print.info('Next steps:');
-  print.info(`  cd ${projectName} && ${packageManager} run serve\n`);
-}

package/lib/src/version.mjs

@@ -1 +0,0 @@
-export const packageVersion = '1.3.1';

package/templates/base/builder.config.js.hbs

@@ -1,36 +0,0 @@
-export default {
-	esbuild: {
-    bundle: true,
-    minify: true,
-    sourcemap: false,
-    drop: ['console', 'debugger'],
-    platform: 'browser',
-    format: 'esm',
-    target: ['es2015'],
-    legalComments: 'none',
-    loader: {
-      '.json': 'json',
-    },
-    define: {
-      'process.env.NODE_ENV': '"production"',
-    },
-	},
-  sass: {
-    paths: [ 
-      'base', 
-      'core',
-{{#if stylinNutin}}
-      'components',
-      'views',
-{{/if}}
-    ], // in styles/
-  },
-{{#if deployHelper}}
-  compression: {
-    gzip: true,
-    // BROTLI OPTIONAL
-    // brotli: false,
-  },
-{{/if}}
-	verbose: false,
-}

package/templates/base/src/app/components/common/anchor/anchor.component.ts.hbs

@@ -1,32 +0,0 @@
-import { AnchorManager, Component, IAnchorConfig } from '../../../../core/index.js';
-
-/**
- * ```typescript
- * interface IAnchorConfig {
-  // prefix href with '#' for internal anchor
-  href: string;
-  target?: string;
-  textContent?: string;
-{{#if i18n}}
-  i18nKey?: string;
-{{/if}}
-  className?: string;
-  style?: string;
-  // use regular pipe syntax for arguments / chaining
-  pipes?: string;
-  tagName?: keyof HTMLElementTagNameMap;
-}
-```
-*/
-export class AnchorComponent extends Component<HTMLAnchorElement, IAnchorConfig> {
-
-  constructor(mountTarget: HTMLElement, config: IAnchorConfig) {
-    super({
-      mountTarget,
-      tagName: config.tagName,
-      config,
-      normalizeKeys: ['style', 'pipes', 'className']
-    });
-    new AnchorManager(config, this.element);
-  }
-}

package/templates/base/src/app/components/common/button/button.component.ts.hbs

@@ -1,40 +0,0 @@
-import { BaseButton, Component } from '../../../../core/index.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 BaseButton extends IAttributesConfig {
-  callback: () => void;
-}
-
-interface ButtonContainerOptions {
-  containerClassName?: string;
-  containerStyles?: string;
-}
-  ```
- * Note : To ensure 'this' is bound properly
- * ```typescript
- // Will handle 'this' inside doStuff
- * { callback: () => this.doStuff() }
- * // Will still work, but won't handle 'this' inside doStuff
- * { callback: this.doStuff }
- * ```
-*/
-export class ButtonComponent extends Component<HTMLButtonElement> {
-  constructor(mountTarget: HTMLElement, button: BaseButton) {
-    super({
-      mountTarget,
-      props: { buttons: [button] }
-    });
-  }
-}

package/templates/base/src/app/dom.test.js.hbs

@@ -1,13 +0,0 @@
-describe('App container', () => {
-  it('should be defined', () => {
-    const appContainer = document.getElementById('app');
-    expect(appContainer).toBeDefined();
-  });
-  it('should have title', () => {
-    expect(document.title).toEqual('{{projectName}}');
-  });
-  it('should have meta description', () => {
-    const desc = document.querySelector('meta[name="description"]').content;
-    expect(desc).toEqual('{{projectName}}');
-  });
-});

package/templates/base/src/app/services/example/example.service.ts.hbs

@@ -1,18 +0,0 @@
-import { Service } from "../../../core/index.js";
-
-export class Example extends Service<Example> {
-  constructor() {
-    super();
-    this.registerCallback();
-  }
-
-  protected registerCallback(): void { 
-    console.debug('No cleanup callbacks registered for service: Example')
-  }
-
-  protected onDestroy(): void {
-    this.dispose();
-  }
-}
-
-export const exampleService = Example.getInstance();

package/templates/base/src/app/views/home/home.view.test.js.hbs

@@ -1,26 +0,0 @@
-import { HomeView } from '#root/dist/src/app/views/index.js';
-
-let view;
-
-describe('HomeView', () => {
-	beforeAll(() => {
-		view = new HomeView();
-	});
-
-	it('should be defined', () => {
-		expect(view).toBeDefined();
-	});
-	{{#if i18n}}
-	it('should have title with i18n key', () => {
-		const h1 = view.element.querySelector('h1');
-		expect(h1).toBeDefined();
-		expect(h1.textContent).toBe('home.title');		
-	});
-	{{else}}
-	it('should have title', () => {
-		const h1 = view.element.querySelector('h1');
-		expect(h1).toBeDefined();
-		expect(h1.textContent).toBe('{{projectName}}');		
-	});
-	{{/if}}
-})

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

@@ -1,8 +0,0 @@
-import { AppStore } from '#root/dist/src/core/services/index.js'
-
-describe('store', () => {
-  it('should set & get values properly', () => {
-    AppStore.set('foo', 123);
-    expect(AppStore.get('foo')).toBe(123)
-  });
-})

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,113 +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);
-      this.scrollToTarget(target);
-      this.accessibilityFeatures(target, id);
-    });
-  }
-
-  private scrollToTarget(target: HTMLElement | null): void {
-    const targetPosition = target?.offsetTop;
-    window.scrollTo({
-      top: targetPosition,
-      behavior: 'smooth'
-    })
-  }
-
-  private accessibilityFeatures(target: HTMLElement | null, id: string) {
-    this.setFocus(target);
-    this.setAriaLive(target, id);
-  }
-
-  private setFocus(target: HTMLElement | null): void {
-    setTimeout(() => {
-      target?.setAttribute('tabindex', '-1');
-      target?.focus({ preventScroll: true });
-      // Remove tabindex after focus
-      target?.addEventListener('blur', () => {
-        target?.removeAttribute('tabindex');
-      }, { once: true });
-    }, 100);
-  }
-
-  private setAriaLive(target: HTMLElement | null, id: string): void {
-    const announcement = document.createElement('div');
-    announcement.setAttribute('aria-live', 'polite');
-    announcement.className = 'sr-only';
-    announcement.textContent = `Navigated to ${ target?.textContent || id }`;
-    document.body.appendChild(announcement);
-    setTimeout(() => document.body.removeChild(announcement), 1000);
-  }
-}

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');
-  });
-})