@nutin/cli 1.2.0 → 1.2.1

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

@@ -72,7 +72,7 @@ async function removeJsonFiles(directory) {
 
   await removeEmptyDirectories(directory);
 
-  if (isVerbose) print.info(`✅ JSON files cleanup complete.`);
+  if (isVerbose) print.boldInfo(`JSON files cleanup complete.`);
 }
 
 async function removeEmptyDirectories(directory) {
@@ -121,7 +121,7 @@ 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(PATHS.tempApp);
 }

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/components/_index.scss.hbs

@@ -1,3 +0,0 @@
-// global components style export
-
-// @forward "my-component";

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

@@ -40,7 +40,7 @@ async function mergeTemplates() {
       print.boldError(`ERROR: Failed to read ${htmlFilename}. ${err.message}`);
     }
   }
-  print.info(`HTML templates minified and merged in scripts.`)
+  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 })); };
+
 }

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

@@ -0,0 +1,59 @@
+global.spyOn = (obj, methodName) => {
+  if (!obj || typeof methodName !== 'string') {
+    throw new Error('spyOn requires an object and a method name');
+  }
+
+  const originalFn = obj[methodName];
+
+  if (typeof originalFn !== 'function') {
+    throw new Error(`Cannot spy on ${methodName} – not a function`);
+  }
+
+  const calls = [];
+
+  function spyFunction(...args) {
+    calls.push(args.slice());
+    if (spyFunction._fake) {
+      return spyFunction._fake.apply(this, args);
+    }
+    if (spyFunction._hasReturn) {
+      return spyFunction._returnValue;
+    }
+    return originalFn.apply(this, args);
+  }
+
+  spyFunction._isSpy = true;
+  spyFunction._fake = null;
+  spyFunction._hasReturn = false;
+  spyFunction._returnValue = undefined;
+
+  obj[methodName] = spyFunction;
+
+  const handle = {
+    restore() {
+      if (obj[methodName] === spyFunction) {
+        obj[methodName] = originalFn;
+      }
+    },
+    get calls() {
+      return calls;
+    },
+    get callCount() {
+      return calls.length;
+    },
+    get lastCall() {
+      return calls.length ? calls[calls.length - 1] : undefined;
+    },
+    andCallFake(fn) {
+      spyFunction._fake = fn;
+      spyFunction._hasReturn = false;
+    },
+    andReturn(value) {
+      spyFunction._returnValue = value;
+      spyFunction._hasReturn = true;
+      spyFunction._fake = null;
+    }
+  };
+
+  return handle;
+};

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

@@ -1,3 +1,5 @@
+import config from '#root/testin-nutin.config.js';
+
 export function printSummary(passed, failed, time) {
   const totalTime = time.toFixed(2);
   const total = passed + failed;
@@ -17,7 +19,7 @@ export function printResults(results) {
 
   sortedResults.forEach(result => {
     if (result.status === 'passed') {
-      console.log(`${chalk.green('✓')} ${chalk.cyan(`${result.suiteName}`)} - ${chalk.green(`${result.name}`)}`);
+      if (config.verbose ) console.log(`${chalk.green('✓')} ${chalk.cyan(`${result.suiteName}`)} - ${chalk.green(`${result.name}`)}`);
     } else {
       print.error(`✗ ${result.suiteName} - ${result.name}`);
       print.grayError(result.error);

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

@@ -3,9 +3,13 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const relativeToCwd = path.relative(process.cwd(), __dirname);
+const levelsUp = relativeToCwd.split(path.sep).length-1;
+const projectRoot = path.resolve(__dirname, ...Array(levelsUp).fill('..'));
 
 export function getTestFiles(dir) {
-  const fullDir = path.resolve(__dirname,'../', '../', '../', dir);
+  const fullDir = path.join(projectRoot, dir);
+  
   if (!fs.existsSync(fullDir)) return [];
   
   function findTestFilesRecursively(currentDir) {

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

@@ -34,9 +34,11 @@ export async function runQueuedTests() {
         previousSuiteAfterAll = test.afterAll;
       }
 
+      setupJsdom();
       if (test.beforeEach) await test.beforeEach();
       await test.testFn();
       if (test.afterEach) await test.afterEach();
+      teardownJsdom();
 
       passed++;
       results.push({ 
@@ -50,7 +52,7 @@ export async function runQueuedTests() {
         suiteName: test.suiteName, 
         status: 'failed', 
         name: test.testName, 
-        error: err.stack 
+        error: err.stack
       });
     }
   }

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

@@ -8,11 +8,17 @@ describe('assertions', () => {
   it('should check if value matches expected', () => {
     const five = obj.add(2,3);
     const ten = obj.add(3,7);
+    const object = { five: five, ten: ten };
+    const arr = [ five, ten ];
 
     expect(five).toEqual(5);
-    expect(five).toBe('5');
+    expect(five).toBe(5);
     expect(ten).not.toEqual(11);
-    expect(ten).not.toBe('11');
+    expect(ten).not.toBe(11);
+    expect(object).toEqual({ five: five, ten: ten });
+    expect(object).not.toBe({ five: five, ten: ten });
+    expect(arr).toEqual([five, ten]);
+    expect(arr).not.toBe([five, ten]);
   });
   it('should check if function has been called', () => {
     const spy = spyOn(obj, 'add');
@@ -29,6 +35,12 @@ describe('assertions', () => {
     expect(null).toBeUndefined();
     expect(null).not.toBeDefined();
   });
+  it('should check for if an element is true / false', () => {
+    const isTrue = 1 == '1';
+    const isFalse = 1 === '1';
+    expect(isTrue).toBeTruthy();
+    expect(isFalse).toBeFalsy();
+  });
   it('should check if substring is contained within string', () => {
     const str1 = 'Creativity is allowing yourself to make mistakes.';
     const str2 = 'Art is knowing which ones to keep.';
@@ -40,7 +52,19 @@ describe('assertions', () => {
   });
   it('should check for instance', () => {
     const date = new Date();
+    const fn = () => {};
     expect(date).toBeInstanceOf(Date);
+    expect(fn).toBeInstanceOf(Function);
     expect(date).not.toBeInstanceOf(Function);
+    expect(fn).not.toBeInstanceOf(Date);
+  });
+  it('should check for error throw', () => {
+    const err = () => { throw new Error('message'); };
+    const notErr = () => {};
+    expect(err).toThrow();
+    expect(err).toThrow('message');
+    expect(err).not.toThrow('another message');
+    expect(notErr).not.toThrow();
+    expect(notErr).not.toThrow('messsage');
   });
 });

package/templates/features/testinNutin/testin-nutin/runner.js.hbs

@@ -0,0 +1,35 @@
+import { registerTestGlobals, getTestFiles, runQueuedTests, print } from './core/index.js';
+import config from '#root/testin-nutin.config.js';
+
+registerTestGlobals();
+
+let testFiles = config.origins.flatMap(
+  origin => getTestFiles(`../${origin}`)
+);
+
+const args = process.argv.slice(2);
+if (args.length) {
+  testFiles = testFiles.filter(file => args.some(f => file.includes(f)));
+}
+
+async function loadTestFile(file) {
+  setupJsdom();
+  await import(file);
+  teardownJsdom();
+}
+
+async function runTests() {
+  if (config.verbose) print.head('Test suites :');
+  for (const file of testFiles) {
+    try {
+      await loadTestFile(file);
+    } catch (error) {
+      print.boldError(`✗ ${file} failed to load:`);
+      print.grayError(error.stack);
+    }
+  }
+
+  await runQueuedTests();
+}
+
+runTests();

package/templates/features/testinNutin/{test → testin-nutin}/watch-tests.js.hbs

@@ -14,7 +14,7 @@ watcher.on('change', (filePath) => {
   console.clear();
   print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), filePath)}\n`);
 
-  exec('node --experimental-modules test/runner.js', (err, stdout, stderr) => {
+  exec('node --experimental-modules testin-nutin/runner.js', (err, stdout, stderr) => {
     if (stdout) process.stdout.write(stdout);
     if (stderr) process.stderr.write(stderr);
   });

package/templates/features/testinNutin/testin-nutin.config.js.hbs

@@ -0,0 +1,14 @@
+export default {
+	origins: [
+		'src/app', // actual app code
+		// 'src/core', // toolkit core logic
+		// 'testin-nutin/core/tests', // test globals
+	],
+	verbose: false,
+	jsdomOptions: {
+    runScripts: false,     // or true ("dangerously") if needed
+    resources: false,      // or true ("usable") if needed
+    freezeGlobals: false,
+    pretendToBeVisual: true,
+  }
+}

package/templates/base/Dockerfile.hbs

@@ -1,33 +0,0 @@
-ARG NODE_VERSION=22.3.0
-ARG NGINX_VERSION=1.27-alpine
-
-FROM node:${NODE_VERSION} AS builder
-WORKDIR /usr/src/app
-COPY . .
-RUN {{ciCommand}} && \
-    {{packageManager}} run build:prod
-
-FROM nginx:${NGINX_VERSION}
-
-RUN rm /etc/nginx/conf.d/default.conf
-COPY --from=builder /usr/src/app/nginx.conf /etc/nginx/conf.d/default.conf
-
-RUN sed -i '/http {/a \
-    # Gzip compression\n\
-    gzip on;\n\
-    gzip_vary on;\n\
-    gzip_proxied any;\n\
-    gzip_comp_level 6;\n\
-    gzip_types text/plain text/css text/xml text/javascript application/json application/javascript application/xml+rss application/rss+xml font/truetype font/opentype application/vnd.ms-fontobject image/svg+xml;\n\
-    gzip_min_length 1000;\n\
-' /etc/nginx/nginx.conf && \
-	touch /var/run/nginx.pid
-
-COPY --from=builder /usr/src/app/dist/src /usr/share/nginx/html
-
-EXPOSE 9090
-
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:9090/health || exit 1
-
-CMD ["nginx", "-g", "daemon off;"]

package/templates/base/nginx.conf.hbs

@@ -1,43 +0,0 @@
-server {
-    listen 9090;
-    server_name _;
-    root /usr/share/nginx/html;
-    index index.html;
-
-    # Security headers
-    add_header X-Frame-Options "SAMEORIGIN" always;
-    add_header X-Content-Type-Options "nosniff" always;
-    add_header X-XSS-Protection "1; mode=block" always;
-    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
-    add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;
-    
-    # Content Security Policy - ADJUST BASED ON YOUR APP'S NEEDS
-    add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self';" always;
-
-    location / {
-        try_files $uri $uri/ /index.html;
-    }
-
-    # Static assets with long cache
-    location ~* \.(js|css|png|jpg|jpeg|gif|avif|ico|svg|woff|woff2|ttf|eot)$ {
-        expires 1y;
-        add_header Cache-Control "public, immutable";
-    }
-
-    # HTML files - no cache
-    location ~* \.html$ {
-        expires -1;
-        add_header Cache-Control "no-cache, no-store, must-revalidate";
-        add_header Pragma "no-cache";
-    }
-
-    # Health check endpoint
-    location /health {
-        access_log off;
-        return 200 "healthy\n";
-        add_header Content-Type text/plain;
-    }
-
-    # Hide nginx version
-    server_tokens off;
-}

package/templates/base/tools/builder/docs.md.hbs

@@ -1,9 +0,0 @@
-- Adding additnal file formats to the build
-Default file formats are `"html" "json" "ttf" "avif" "png" "jpg"`.          
-Only the files in src/ that match one of the format are copied.
-In `tools/builder/variables/file-types.js`, add desired format to existing list. Adding a file extension with no match in src/ will have no effect.            
-                                 
-- Build Sequence
-
-
-[**Back to index**](../../README.md)

package/templates/base/tools/dev.js.hbs

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from 'child_process';
-import { print, runCommand } from './utils/index.js';
-
-function run(command, args = [], label = '') {
-  return new Promise((resolve, reject) => {
-    print.info(`\n▶ ${label || command}...`);
-
-    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}`));
-    });
-  });
-}
-
-async function startDev() {
-  try {
-    console.clear();
-    print.boldHead('🚀 Starting Dev Environment...');
-
-    await run('{{packageManager}}', ['run', 'build'], 'Running initial build');
-
-    const serve = spawn('{{packageManager}}', ['run', 'serve:only'], { stdio: 'inherit', shell: true });
-    const watcher = spawn('node', ['tools/watcher.js'], { stdio: 'inherit', shell: true });
-
-    print.boldSuccess('\nDev server and watcher running!\n');
-
-    serve.on('close', (code) => {
-      print.error(`live-server exited with code ${code}`);
-      process.exit(code);
-    });
-    watcher.on('close', (code) => {
-      print.error(`watcher exited with code ${code}`);
-    });
-  } catch (err) {
-    print.boldError(`Dev startup failed: ${err.message}`);
-  }
-}
-
-startDev();