@nutin/cli 1.1.0 → 1.2.1

package/templates/base/tools/generator/handle-file.js.hbs

@@ -1,10 +1,12 @@
 import fs from 'fs';
 import path from 'path';
-import { print } from '../utils/index.js';
+import { print{{#if i18n}}, LANGUAGES{{/if}} } from '../utils/index.js';
 {{#if i18n}}
-import { LANGUAGES } from '../../src/app/languages.js';
 import { jsonTemplate } from './templates/index.js';
 {{/if}}
+{{#if stylinNutin}}
+import { scssTemplate } from './templates/index.js';
+{{/if}}
 
 export function generateFile({
   name,
@@ -59,4 +61,32 @@ export function generateJson({ targetPath, name }) {
   });
 }
 
+{{/if}}
+{{#if stylinNutin}}
+export function generateStylesheet({ name, suffix }) {
+  const template = scssTemplate();
+  const stylesPath = path.join('src', 'styles', `${suffix}s`);
+  const filePath = path.join(stylesPath, `_${name.kebab}.${suffix}.scss`);
+  const indexPath = path.join(stylesPath, `_index.scss`);
+  
+  if (!fs.existsSync(stylesPath) || !fs.existsSync(indexPath)) {
+    print.boldError('Non existing path');
+    process.exit(1);
+  }
+  if (fs.existsSync(filePath)) {
+    print.boldError('A file with this name already exists');
+    process.exit(1);
+  }
+
+  fs.writeFileSync(filePath, template);
+
+  const lineToAppend = `@forward "${name.kebab}.${suffix}";\n`;
+
+  try {
+    fs.appendFileSync(indexPath, lineToAppend, 'utf8');
+  } catch (err) {
+    print.error(`Error appending line: ${err}`);
+  }
+}
+
 {{/if}}

package/templates/base/tools/generator/templates/index.js.hbs

@@ -7,3 +7,6 @@ export * from './html.template.js';
 {{#if i18n}}
 export * from './json.template.js';
 {{/if}}
+{{#if stylinNutin}}
+export * from './scss.template.js';
+{{/if}}

package/templates/base/tools/utils/export-flags.js.hbs

@@ -0,0 +1,6 @@
+import process from 'process';
+import builderConfig from '../../builder.config.js';
+
+export const isProd = process.env.npm_config_bundle || process.env.NODE_ENV === 'production';
+
+export const isVerbose = process.env.npm_config_log || builderConfig.verbose;

package/templates/base/tools/utils/get-files-recursive.js.hbs

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 export function getFilesRecursive(dir, extension) {
-  const fullDir = path.resolve(process.cwd(), dir);
+  const fullDir = path.resolve(dir);
 
   if (!fs.existsSync(fullDir)) return [];
   
@@ -14,10 +14,8 @@ export function getFilesRecursive(dir, extension) {
       const fullPath = path.join(currentDir, item.name);
       
       if (item.isDirectory()) {
-        // Recursively search subdirectories
         files.push(...findFilesRecursively(fullPath));
       } else if (item.isFile() && item.name.endsWith(extension)) {
-        // Add  files to the results
         files.push(fullPath);
       }
     }

package/templates/base/tools/utils/index.js.hbs

@@ -1,3 +1,10 @@
 export * from './print.js';
 export * from './format.js';
-export * from './get-files-recursive.js';
+export * from './get-files-recursive.js';
+export * from './run-command.js';
+export * from './run-script.js';
+export * from './export-flags.js';
+export * from './prompt-boolean.js';
+{{#if i18n}}
+export * from './languages.js';
+{{/if}}

package/templates/base/tools/utils/prompt-boolean.js.hbs

@@ -0,0 +1,15 @@
+import readline from 'readline';
+
+export const promptBoolean = (question) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/n): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+};

package/templates/base/tools/utils/run-command.js.hbs

@@ -0,0 +1,12 @@
+import { spawn } from 'child_process';
+
+export function runCommand(command, args = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'inherit', shell: true });
+
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with code ${code}`));
+    });
+  });
+}

package/templates/base/tools/utils/run-script.js.hbs

@@ -0,0 +1,22 @@
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+import process from 'process';
+import { print } from './index.js';
+
+export function runScript(path, message) {
+  print.boldSection(message);
+
+  const args = [resolve(path)];
+
+  const result = spawnSync('node', args, 
+    { 
+      stdio: 'inherit',
+      env: { ...process.env }, 
+    }
+  );
+
+  if (result.status !== 0) {
+    print.boldError(`\nScript ${path} failed.`);
+    process.exit(result.status ?? 1);
+  }
+}

package/templates/features/i18n/src/core/config.ts.hbs

@@ -0,0 +1,3 @@
+import langs from '../../config/languages.json' with { type: 'json' };
+
+export const CONFIG = { langs } as const;

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

@@ -65,6 +65,8 @@ describe('i18n module', async () => {
       configurable: true,
       value: "en-US"
     });
+    I18nService['_LANGUAGES'] = [ 'en', 'fr' ];
+    I18nService['_DEFAULT_LANGUAGE'] = 'en';
   });
   afterAll(() => {    
     Object.defineProperty(navigator, 'language', {

package/templates/features/i18n/src/core/services/i18n/i18n.ts.hbs

@@ -1,4 +1,4 @@
-import { DEFAULT_LANGUAGE, LANGUAGES, Language, Translations } from '../../../app/languages.js';
+import { DEFAULT_LANGUAGE, LANGUAGES, Language, Translations } from './languages.js';
 import { Service } from '../../index.js';
 
 export class I18n extends Service<I18n> {
@@ -11,6 +11,7 @@ export class I18n extends Service<I18n> {
   constructor() {
     super();
     this.registerCleanup(this.resetTranslations);
+    this._currentLanguage = this.getBrowserLanguage();
   }
 
   private getBrowserLanguage() {
@@ -89,6 +90,14 @@ export class I18n extends Service<I18n> {
     return this._currentLanguage;
   }
 
+  public get defaultLanguage(): Language {
+    return this._DEFAULT_LANGUAGE;
+  }
+
+  public get languages(): Language[] {
+    return this._LANGUAGES;
+  }
+
   public async initTranslations(): Promise<void> {
     const browserLang = this.getBrowserLanguage();
     const lang = this._LANGUAGES.includes(browserLang) ? browserLang : this._DEFAULT_LANGUAGE;

package/templates/features/i18n/src/core/services/i18n/languages.ts.hbs

@@ -0,0 +1,7 @@
+import { CONFIG } from '../../config.js';
+
+export const LANGUAGES = CONFIG.langs.languages;
+export const DEFAULT_LANGUAGE = CONFIG.langs.defaultLanguage as (typeof LANGUAGES)[number];
+
+export type Language = typeof LANGUAGES[number];
+export type Translations = Record<string, any>;

package/templates/features/i18n/tools/builder/core/build-i18n.js.hbs

@@ -1,19 +1,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { exit } from 'process';
-import { getFilesRecursive, print } from '../../utils/index.js';
+import { getFilesRecursive, print, isVerbose } from '../../utils/index.js';
+import { PATHS } from './paths.js';
 
-const sourceRoot = './src/app';
-{{#if template}}
-const destDir = './dist-build/src/locales';
-const cleanupDir = './dist-build/src/app';
-{{else}}
-const destDir = './dist/src/locales';
-const cleanupDir = './dist/src/app';
-{{/if}}
+const destDir = path.join(PATHS.tempSource, 'locales');
 
 function findLocaleFiles() {
-  const allFiles = getFilesRecursive(sourceRoot, '.json');
+  const allFiles = getFilesRecursive(PATHS.sourceApp, '.json');
   const localeFileMap = {};
 
   allFiles.forEach(file => {
@@ -66,18 +60,19 @@ async function removeJsonFiles(directory) {
     if (file.includes(`${path.sep}locales${path.sep}`)) {
       try {
         await fs.promises.unlink(file);
-        print.info(`Deleted locale JSON file: ${file}`);
+        if (isVerbose) print.info(`Deleted locale JSON file: ${file}`);
       } catch (err) {
         print.error(`Failed to remove ${file}: ${err.message}`);
       }
-    } else {
+    } 
+    else if (isVerbose) {
       print.info(`Skipping non-locale JSON file: ${file}`);
     }
   }
 
   await removeEmptyDirectories(directory);
 
-  print.info(`✅ JSON files cleanup complete.`);
+  if (isVerbose) print.boldInfo(`JSON files cleanup complete.`);
 }
 
 async function removeEmptyDirectories(directory) {
@@ -102,12 +97,12 @@ async function removeEmptyDirectories(directory) {
     }
   }
 
-  if (directory !== cleanupDir) {
+  if (directory !== PATHS.tempApp) {
     try {
       const updatedItems = await fs.promises.readdir(directory);
       if (updatedItems.length === 0) {
         await fs.promises.rmdir(directory, { recursive: false });
-        print.info(`📁 Removed empty directory: ${directory}`);
+        if (isVerbose) print.info(`📁 Removed empty directory: ${directory}`);
       }
     } catch (err) {
       print.error(`Failed to remove empty directory ${directory}: ${err.message}`);
@@ -126,9 +121,9 @@ async function mergeJson() {
       `${destDir}/${locale}.json`,
       JSON.stringify(combined, null, 2)
     );
-    print.info(`✅ Json files for locale ${locale} merged successfully`);
+    if (isVerbose) print.boldInfo(`Json files for locale ${locale} merged successfully`);
   }
-  removeJsonFiles(cleanupDir);
+  removeJsonFiles(PATHS.tempApp);
 }
 
 mergeJson().catch((err) => {

package/templates/features/i18n/tools/utils/languages.js.hbs

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+
+const langsPath = path.join(process.cwd(), 'config', 'languages.json');
+const langs = JSON.parse(fs.readFileSync(langsPath, 'utf-8'));
+export const LANGUAGES = langs.languages;
+export const DEFAULT_LANGUAGE = langs.defaultLanguage;

package/templates/features/stylinNutin/src/styles/_custom-classes.scss.hbs

@@ -5,5 +5,5 @@
 /*
 	 Add your classes here
 	 Custom classes prefix : 'c-'
-	 Component- or view-specific classes prefix : '/name/__'
+	 ( prefix view-specific classes with viewname__ )
 */

package/templates/features/stylinNutin/tools/generator/templates/scss.template.js.hbs

@@ -0,0 +1,4 @@
+export const scssTemplate = () => `@use "sass:map";
+@use "variables" as *;
+@use "mixins";
+`;

package/templates/features/template/tools/builder/core/merge-templates.js.hbs

@@ -1,52 +1,38 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { exit } from 'process';
-import { print } from '../../utils/index.js';
+import { getFilesRecursive, print, isVerbose, isProd } from '../../utils/index.js';
+import { minifyHTML } from './minify-html.js';
+import { PATHS } from './paths.js';
 
-const JS_DIR = 'dist-build/src/app';
 const PLACEHOLDER = '__TEMPLATE_PLACEHOLDER__';
 
-async function findHtmlFiles(dir) {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const files = await Promise.all(
-    entries.map(async (entry) => {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        return findHtmlFiles(fullPath);
-      } else if (entry.isFile() && fullPath.endsWith('.html')) {
-        return [fullPath];
-      }
-      return [];
-    })
-  );
-  return files.flat();
-}
-
 async function mergeTemplates() {
-  const htmlFiles = await findHtmlFiles(JS_DIR);
+  const htmlFiles = await getFilesRecursive(PATHS.tempApp, 'html');
+  const fileExtension = isProd ? '.ts' : '.js';
 
   for (const htmlPath of htmlFiles) {
-    const jsPath = htmlPath.replace(/\.html$/, '.js');
+    const jsPath = htmlPath.replace(/\.html$/, fileExtension);
     const htmlFilename = path.basename(htmlPath);
     const jsFilename = path.basename(jsPath);
 
     try {
       const htmlContent = await fs.readFile(htmlPath, 'utf-8');
-      const minified = htmlContent.replace(/\n/g, '');
-      const escaped = minified.replace(/([\\/&`"])/g, '\\$1');
+      const minifiedHtml = await minifyHTML(htmlContent);
+      if (isVerbose) print.info(`Minified HTML: ${file}`);
 
       try {
         let jsContent = await fs.readFile(jsPath, 'utf-8');
         if (!jsContent.includes(PLACEHOLDER)) {
           print.boldError(`WARNING: No matching placeholder in ${jsFilename}`);
-          print.error(`If you're using external templates, make sure the template const is \`${PLACEHOLDER}\`.`);
-          print.error(`If using inline templates, remove ${htmlFilename}.`);
+          print.error(`Make sure the template const is \`${PLACEHOLDER}\`.`);
           exit(1);
         }
 
-        jsContent = jsContent.replace(PLACEHOLDER, escaped);
+        jsContent = jsContent.replace(PLACEHOLDER, minifiedHtml);
         await fs.writeFile(jsPath, jsContent);
-        print.info(`✅ Updated ${jsFilename} with template from ${htmlFilename}.`);
+        await fs.unlink(htmlPath);
+        if (isVerbose) print.info(`✅ Updated ${jsFilename} with template from ${htmlFilename}.`);
       } catch (err) {
         print.boldError(`ERROR: Cannot update ${jsFilename}. ${err.message}`);
       }
@@ -54,6 +40,7 @@ async function mergeTemplates() {
       print.boldError(`ERROR: Failed to read ${htmlFilename}. ${err.message}`);
     }
   }
+  if (isVerbose) print.info(`HTML templates minified and merged in scripts.\n`)
 }
 
 mergeTemplates().catch((err) => {

package/templates/features/testinNutin/{test → testin-nutin}/core/index.js.hbs

@@ -1,4 +1,4 @@
-export * from './src/jsdom-setup.js';
+export * from './src/globals/jsdom-setup.js';
 export * from './src/globals/register-test-globals.js';
 export * from './src/utils/print.js';
 export * from './src/utils/test-discovery.js';

package/templates/features/testinNutin/testin-nutin/core/src/globals/assertion-lib.js.hbs

@@ -0,0 +1,136 @@
+global.expect = (actual) => {
+  const expectObj = {
+    toBe(expected) {
+      if (actual !== expected) {
+        throw new Error(`Expected ${actual} to be strictly equal to ${expected}`);
+      }
+    },
+    toEqual(expected) {
+      const deepEqual = (a, b) => {
+        if (a === b) return true;
+        if (typeof a !== typeof b) return false;
+        if (Array.isArray(a) && Array.isArray(b)) {
+          return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+        }
+        if (a && b && typeof a === 'object') {
+          const keysA = Object.keys(a);
+          const keysB = Object.keys(b);
+          if (keysA.length !== keysB.length) return false;
+          return keysA.every(k => deepEqual(a[k], b[k]));
+        }
+        return false;
+      };
+
+      if (!deepEqual(actual, expected)) {
+        throw new Error(`Expected ${JSON.stringify(actual)} to deeply equal ${JSON.stringify(expected)}`);
+      }
+    },
+    toContain(substring) {
+      if (!actual.includes(substring)) {
+        throw new Error(`Expected '${actual}' to contain '${substring}'`);
+      }
+    },
+    toBeTruthy() {
+      if (!actual) {
+        throw new Error(`Expected ${actual} to be truthy`);
+      }
+    },
+    toBeFalsy() {
+      if (actual) {
+        throw new Error(`Expected ${actual} to be falsy`);
+      }
+    },
+    toBeDefined() {
+      if (actual === null || actual === undefined) {
+        throw new Error(`Expected value to be defined, but got ${actual}`);
+      }
+    },
+    toBeUndefined() {
+      if (actual !== null && actual !== undefined) {
+        throw new Error(`Expected value to be undefined, but got ${actual}`);
+      }
+    },
+    toBeInstanceOf(constructor) {
+      if (!(actual instanceof constructor)) {
+        throw new Error(`Expected ${actual} to be instance of ${constructor.name}`);
+      }
+    },
+    toHaveBeenCalled() {
+      if (!actual?.calls || actual.calls.length === 0) {
+        throw new Error(`Expected function to have been called, but it was not`);
+      }
+    },
+    toHaveBeenCalledWith(...expectedArgs)  {
+      const deepEqual = (a, b) => {
+        if (a === b) return true;
+        if (typeof a !== typeof b) return false;
+
+        if (Array.isArray(a) && Array.isArray(b)) {
+          return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+        }
+
+        if (a && b && typeof a === 'object') {
+          const keysA = Object.keys(a);
+          const keysB = Object.keys(b);
+          if (keysA.length !== keysB.length) return false;
+          return keysA.every(k => deepEqual(a[k], b[k]));
+        }
+
+        return false;
+      };
+
+      const matched = actual?.calls?.some(args =>
+        args.length === expectedArgs.length &&
+        args.every((arg, i) => deepEqual(arg, expectedArgs[i]))
+      );
+
+      if (!matched) {
+        throw new Error(
+          `Expected function to have been called with ${JSON.stringify(expectedArgs)}, but it was not.\n` +
+          `Actual calls:\n${JSON.stringify(actual?.calls, null, 2)}`
+        );
+      }
+    },
+    toBeLessThan(expected) {
+      if (actual > expected) {
+        throw new Error(`Expected ${actual} to be less than ${expected}`)
+      }
+    },
+    toBeGreaterThan(expected) {
+      if (actual < expected) {
+        throw new Error(`Expected ${actual} to be greater than ${expected}`)
+      }
+    },
+    toThrow(expectedMessage) {
+      let threw = false;
+      try {
+        actual();
+      } catch (err) {
+        threw = true;
+        if (expectedMessage && !err.message.includes(expectedMessage)) {
+          throw new Error(`Expected error message to include "${expectedMessage}", but got "${err.message}"`);
+        }
+      }
+      if (!threw) {
+        throw new Error(`Expected function to throw, but it did not`);
+      }
+    },
+  };
+
+  // 'not' variants
+  expectObj.not = {};
+  for (const [name, fn] of Object.entries(expectObj)) {
+    if (name === 'not') continue;
+    if (typeof fn !== 'function') continue;
+
+    expectObj.not[name] = (...args) => {
+      try {
+        fn(...args);
+      } catch {
+        return;
+      }
+      throw new Error(`Expected NOT: ${name}(${JSON.stringify(args)})`);
+    };
+  }
+  return expectObj;
+};

package/templates/features/testinNutin/testin-nutin/core/src/globals/jsdom-setup.js.hbs

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import path from 'path';
+import { JSDOM } from 'jsdom';
+import config from '#root/testin-nutin.config.js';
+let currentDom = null;
+
+export function setupJsdom(htmlPath = 'dist/src/index.html') {
+  const html = fs.readFileSync(path.resolve(process.cwd(), htmlPath), 'utf8');
+
+  const {
+    runScripts,
+    resources,
+    freezeGlobals,
+    pretendToBeVisual,
+  } = config.jsdomOptions;
+
+  const dom = new JSDOM(html, {
+    url: 'http://localhost',
+    runScripts: runScripts ? 'dangerously' : undefined,
+    resources: resources ? 'usable' : undefined,
+    pretendToBeVisual,
+  });
+
+  currentDom = dom;
+
+  global.window = dom.window;
+  global.document = dom.window.document;
+
+  // DOM globals
+  Object.getOwnPropertyNames(dom.window)
+    .filter(prop => !(prop in global))
+    .forEach(prop => {
+      global[prop] = dom.window[prop];
+  });
+
+  global.localStorage = dom.window.localStorage;
+
+  window.matchMedia ??= () => ({
+    matches: false,
+    addEventListener: () => {},
+    removeEventListener: () => {},
+  });
+
+  window.scrollTo ??= () => {};
+
+  window.requestAnimationFrame ??= (cb) => setTimeout(cb, 0);
+  window.cancelAnimationFrame ??= (id) => clearTimeout(id);
+
+  window.IntersectionObserver ??= class {
+    constructor() {}
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
+
+  window.ResizeObserver ??= class {
+    constructor() {}
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
+
+  if (freezeGlobals) {
+    Object.freeze(global.window);
+    Object.freeze(global.document);
+  }
+
+  return dom;
+}
+
+export function teardownJsdom() {
+  if (currentDom) {
+    try {
+      currentDom.window.close();
+    } catch {}
+  }
+
+  currentDom = null;
+
+  delete global.window;
+  delete global.document;
+  delete global.localStorage;
+}
+
+export function resetDom() {
+  if (!global.document) return;
+
+  document.body.innerHTML = '';
+  document.head.innerHTML = '<meta charset="UTF-8">';
+
+  if (global.localStorage) {
+    localStorage.clear();
+  }
+}
+
+export function flushPromises() {
+  return new Promise(setImmediate);
+}
+
+export const $ = (selector) => document.querySelector(selector);
+export const $$ = (selector) => [...document.querySelectorAll(selector)];

package/templates/features/testinNutin/{test → testin-nutin}/core/src/globals/register-test-globals.js.hbs

@@ -1,4 +1,6 @@
 import { print, addTest } from '../../index.js';
+import config from '#root/testin-nutin.config.js';
+import { setupJsdom, teardownJsdom, resetDom, flushPromises } from './jsdom-setup.js';
 import './assertion-lib.js';
 import './spyon.js';
 
@@ -14,7 +16,7 @@ export function registerTestGlobals() {
       afterEach: null,
       afterAll: null
     };
-    print.boldSuccess('📂 ' + name);
+    if (config.verbose) print.boldSuccess('📂 ' + name);
     fn();
   };
 
@@ -42,4 +44,16 @@ export function registerTestGlobals() {
   global.afterEach = (fn) => {
     currentSuiteHooks.afterEach = fn;
   };
+
+  global.setupJsdom = setupJsdom;
+  global.teardownJsdom = teardownJsdom;
+  global.resetDom = resetDom;
+  global.flushPromises = flushPromises;
+
+  global.$ = (selector) => document.querySelector(selector);
+  global.$$ = (selector) => [...document.querySelectorAll(selector)];
+
+  global.click = (el) => el.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+  global.type = (el, text) => { el.value = text; el.dispatchEvent(new window.InputEvent("input", { bubbles: true })); };
+
 }