@massimo-cassandro/minimo 1.8.4 → 1.9.1

package/dev-tools/upd@m/index.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+/* eslint-env node */
+
+// run npm update for all packeges inside `node_modules/@massimo-cassandro` folder
+
+import * as fs from 'fs';
+import {execSync} from 'child_process';
+// https://nodejs.org/api/util.html#utilstyletextformat-text-options
+import { styleText } from 'node:util';
+
+const folder = './node_modules/@massimo-cassandro',
+  packages = {};
+
+try {
+
+  if(!fs.existsSync(folder)) {
+    throw `${folder} non presente.`;
+  }
+
+  let maxLength = [];
+
+  fs.readdirSync(folder).forEach(item => {
+    let stats = fs.statSync(`${folder}/${item}`); // stats.isFile() / stats.isDirectory()
+    if(stats.isDirectory()) {
+
+      const packageJsonFile = `${folder}/${item}/package.json`;
+
+      if(!fs.existsSync(packageJsonFile)) {
+        throw `File 'package.json' in '${item}' non presente.`;
+      }
+
+      const packageJsonContent = JSON.parse(fs.readFileSync(packageJsonFile, 'utf8'));
+
+      packages[packageJsonContent.name] = {
+        file    : packageJsonFile,
+        oldVers : packageJsonContent.version
+      };
+
+      maxLength = Math.max(maxLength, packageJsonContent.name.length);
+    }
+  });
+
+  if(Object.keys(packages).length) {
+    execSync(`npm update --save ${Object.keys(packages).join(' ')}`, {stdio: 'inherit'});
+  }
+
+  // lettura versioni aggiornate
+  Object.keys(packages).forEach(p => {
+    const packageJsonContent = JSON.parse(fs.readFileSync(packages[p].file, 'utf8'));
+    packages[p].newVers = packageJsonContent.version;
+  });
+
+
+  console.log( '\n' +
+    Object.keys(packages).map(p =>
+      styleText(
+        [packages[p].oldVers === packages[p].newVers? 'green' : 'yellow'],
+        `  • ${p.padEnd(' ', maxLength)}` +
+        ' : ' +
+        `${packages[p].oldVers} => ${packages[p].newVers}`
+      )
+    ).join('\n')
+  );
+
+  console.log( '\n' + styleText(['bold', 'bgGreen'], ' Aggiornamento completato. ' ) + '\n');
+
+} catch(e) {
+
+  console.log( styleText(['red'], `\n${e}\n` ) );
+}

package/dev-tools/update-version/README.md

@@ -0,0 +1,19 @@
+# Update Version
+
+Reads the version stored in `package.json`, updates it, and maintains a log file.
+
+Each update adds a line to the `changelog.md` file located at the project root. Each line contains the date, the updated version, and optionally, a descriptive text.
+
+The updated version number and descriptive text are copied to the clipboard to speed up commenting for any subsequent commits.
+
+Usage:
+
+```bash
+npx update-version <options>
+```
+
+Options:
+
+* `--pkg`: Path to the `package.json` file relative to the current directory (default: `./package.json`)
+* `--log-file`: Path to the log file relative to the current directory (default: `./changelog.md`). If the file name ends with `.txt`, the log type is assumed to be the previous version of `update-version`, where each line is in the form `timestamp | version | description`
+* `--log-patch`: If present, patch changes are also recorded in the log.

package/dev-tools/update-version/convert-changelog.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/* global process */
+/* eslint-disable no-console */
+
+import fs from 'fs';
+import path from 'path';
+
+// crea un file `changelog-converted.md` dal precedente `changelog.txt`
+
+const changelogPath = path.join(process.cwd(), 'changelog.txt');
+
+// Verifica se il parametro --include-patch è stato passato
+// se presente vengono conservati anche i log delle patch
+const includePatch = process.argv.includes('--include-patch');
+
+let changelogContent;
+
+if (fs.existsSync(changelogPath)) {
+  changelogContent = fs.readFileSync(changelogPath, 'utf-8');
+
+  // Processa ogni riga del changelog
+  const md = changelogContent.trim().split('\n').reduce((prev, curr) => {
+    // Splitta la riga in tre parti (timestamp | versione | descrizione)
+    const parts = curr.split('|').map(part => part.trim());
+
+    if (parts.length !== 3) {
+      return prev;
+    }
+
+    const [timestamp, version, description] = parts;
+
+    // Estrae i numeri di major, minor, patch dalla versione semver (es: 1.0.1)
+    const versionParts = version.split('.').map(Number);
+    const [,, patch] = versionParts;
+
+    // Determina il tipo di update
+    // Se patch è 0, è un major/minor update e va sempre incluso
+    // Se patch > 0, è un patch update e va incluso solo con --include-patch
+    const isPatchUpdate = patch > 0;
+    const shouldInclude = !isPatchUpdate || includePatch;
+
+    if (shouldInclude) {
+      // Aggiunge alla lista la versione e la descrizione
+      prev.push(
+        `* ${version} (${new Date(timestamp).toLocaleString('it-IT', {
+            year: 'numeric',
+            month: 'short',
+            day: '2-digit'
+          })})` +
+          `${description? ' - ' + description: ''}`
+      );
+    }
+
+    return prev;
+  }, []);
+
+  fs.writeFileSync(path.join(process.cwd(), 'changelog-converted.md'),
+    '# Changelog\n\n' +
+    md.join('\n') + '\n')
+  ;
+
+} else {
+  console.log('File changelog.txt non trovato nella directory attuale');
+  process.exit(1);
+}
+

package/dev-tools/update-version/index.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+/* global process */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { params } from './src/params.mjs';
+import { chooser } from './src/chooser-inquirer.mjs';
+import { getCliParams } from './src/get-cli-params.mjs';
+import { updateSemver } from './src/update-semver.mjs';
+import { createLogRow } from './src/create-log-row.mjs';
+import { updateLogFile } from './src/update-log-file.mjs';
+import { updatePackageJson } from './src/update-packageJson.mjs';
+
+import clipboard from 'clipboardy';
+
+// https://nodejs.org/api/util.html#utilstyletextformat-text-options
+import { styleText } from 'node:util';
+
+async function run() {
+  // parametri da riga di comando
+  getCliParams();
+
+  // risoluzione percorsi assoluti rispetto alla dir corrente
+  params.packageJsonFile = path.resolve(process.cwd(), params.packageJsonFile);
+  params.logFile = path.resolve(process.cwd(), params.logFile);
+
+  // check package.json
+  if (!fs.existsSync(params.packageJsonFile)) {
+    console.error( styleText(['red'], `Errore: ${params.packageJsonFile} non trovato.` ));
+    process.exit(1);
+
+  }
+
+  params.packageJsonObj = JSON.parse(fs.readFileSync(params.packageJsonFile, 'utf8'));
+  params.oldSemver = params.packageJsonObj.version;
+
+  if(!params.oldSemver) {
+    console.error( styleText(['red'], `Proprietà 'version' di '${params.cfg.packageJsonFile}' non presente` ));
+
+  } else {
+    console.log( styleText(['white', 'dim'], `Versione package.json attuale: ${params.oldSemver}` ) );
+    params.semverArray = params.oldSemver.split('.').map(i => isNaN(i) ? i : +i);
+  }
+
+  //
+  const choice = await chooser();
+
+  if(choice) {
+    params.updateMode = choice; // modalità scelta (init, major, minor o patch)
+    updateSemver();
+
+    params.logRow.vers = params.newSemver;
+
+    // Scrive il log, se richiesto
+    if(params.addLog) {
+      createLogRow();
+
+      if(!params.debug) {
+        updateLogFile();
+      }
+    }
+
+    // Aggiorna package.json SOLO se non è una inizializzazione
+    if (params.updateMode !== 'init' && !params.debug) {
+      updatePackageJson();
+    }
+
+    // END
+
+    if(params.debug) {
+      console.log(params);
+    }
+
+    clipboard.writeSync(
+      ('v.' + params.newSemver) +
+      (params.logRow.descr
+        ? ' - ' + params.logRow.descr
+        : params.updateMode === 'patch'
+          ? ' - Upd / Fix / Dependencies upd'
+          : '')
+    );
+
+
+    const setOutputRow = (text, rowLength, dim = false) =>
+        styleText(['yellow'], '│ ') +
+        styleText(['yellow', ...(dim? ['dim'] : [])], text) +
+        ' '.repeat(rowLength - text.length - 1) +
+        styleText(['yellow'], '│'),
+
+      outputString1 = `👍 Versione aggiornata: ${params.oldSemver} → ${params.newSemver}`,
+      outputString2 = params.logRow.fullText? `Log: ${params.logRow.fullText}` : '',
+      outputLenght = Math.max(outputString1.length, outputString2.length ) + 2, // 2 = spazi esterni
+      frameLine = '─'.repeat(outputLenght);
+
+    console.log( styleText(['yellow'], '\n┌' + frameLine + '┐' ));
+
+    console.log( setOutputRow(outputString1, outputLenght));
+
+    if(outputString2) {
+      console.log( setOutputRow(outputString2, outputLenght, true));
+    }
+
+    console.log( styleText(['yellow'], '└' + frameLine + '┘\n' ));
+  }
+}
+
+run().catch(console.error);

package/dev-tools/update-version/src/chooser-inquirer.mjs

@@ -0,0 +1,43 @@
+import select from '@inquirer/select';
+import input from '@inquirer/input';
+import * as fs from 'fs';
+import { params } from './params.mjs';
+
+export async function chooser() {
+  const choices = [
+    { name: 'Aggiorna Patch version', value: 'patch' },
+    { name: 'Aggiorna Minor version', value: 'minor' },
+    { name: 'Aggiorna Major version', value: 'major' }
+  ];
+
+  // Se il file di log non esiste, proponi l'inizializzazione
+  if (!fs.existsSync(params.logFile)) {
+    choices.unshift({
+      name: `Inizializza Changelog (v${params.oldSemver})`,
+      value: 'init'
+    });
+  }
+
+  choices.push({ name: 'Annulla', value: null });
+
+  const answer = await select({
+    message: 'Cosa vuoi aggiornare?',
+    choices: choices
+  });
+
+  params.addLog = params.toLog.indexOf(answer) !== -1 || answer === 'init';
+
+  if (answer && params.addLog) {
+    const descr = await input({
+      message: 'Descrizione (opzionale): ',
+      default: answer === 'init'
+        ? 'Setup'
+        : answer === 'patch'
+          ? 'Upd / Fix / Dependencies upd'
+          : ''
+    });
+    params.logRow.descr = descr.trim() || null;
+  }
+
+  return answer;
+}

package/dev-tools/update-version/src/create-log-row.mjs

@@ -0,0 +1,25 @@
+import { params } from './params.mjs';
+
+export function createLogRow() {
+
+
+  if (params.markdownLog) {
+
+    const dateStr = params.logRow.date.toLocaleString(params.locale, {
+      year: 'numeric', month: 'short', day: '2-digit'
+    });
+    params.logRow.fullText = `* ${params.logRow.vers} (${dateStr})${params.logRow.descr ? ' - ' + params.logRow.descr : ''}`;
+
+
+  } else {
+
+    const dateStr = params.logRow.date.toISOString();
+    params.logRow.fullText = `${dateStr} | ${(' '.repeat(16) + params.logRow.vers).slice(-16)} | ${params.logRow.descr || ''}`;
+
+  }
+
+
+
+}
+
+

package/dev-tools/update-version/src/get-cli-params.mjs

@@ -0,0 +1,28 @@
+/* global process */
+
+import { params } from './params.mjs';
+
+export function getCliParams() {
+  const args = process.argv.slice(2);
+
+  args.forEach(arg => {
+
+    // Percorso package.json
+    if (arg.startsWith('--pkg=')) {
+      params.packageJsonFile = arg.split('=')[1].trim();
+    }
+
+    // Percorso file di log
+    if (arg.startsWith('--log-file=')) {
+      params.logFile = arg.split('=')[1].trim();
+      // Se il file finisce in .txt, disabilita markdownLog
+      if (params.logFile.endsWith('.txt')) params.markdownLog = false;
+    }
+
+    // Abilita log anche per le patch
+    if (arg === '--log-patch') {
+      if (!params.toLog.includes('patch')) params.toLog.push('patch');
+    }
+
+  });
+}

package/dev-tools/update-version/src/params.mjs

@@ -0,0 +1,26 @@
+export const params = {
+  // Valori di default
+
+  packageJsonFile: './package.json',
+  logFile: './changelog.md',
+  markdownLog: true,
+  toLog: ['major', 'minor'], // opzionale 'patch'
+  locale: 'it-IT',
+
+  debug: false, // solo sviluppo, non aggiorna nulla ma mostra l'output finale
+
+  addLog: true, // modificato in base alla scelta del tipo di aggironamento e del valore di toLog
+
+
+  // preRealeaseTags: ['alpha', 'beta', 'rc'],
+  logRow: {
+    vers: null,
+    date: new Date(),
+    descr: null,
+    fullText: ''
+  },
+  oldSemver: null,
+  newSemver: null,
+  semverArray: [],
+  updateMode: null
+};

package/dev-tools/update-version/src/update-log-file.mjs

@@ -0,0 +1,17 @@
+import * as fs from 'fs';
+import { params } from './params.mjs';
+
+export function updateLogFile() {
+
+
+  if(params.logRow.fullText) {
+
+    let text = params.logRow.fullText;
+
+    if(params.updateMode === 'init' && params.markdownLog) {
+      text = '# Changelog\n\n' + params.logRow.fullText;
+    }
+
+    fs.appendFileSync(params.logFile, text + '\n');
+  }
+}

package/dev-tools/update-version/src/update-packageJson.mjs

@@ -0,0 +1,10 @@
+
+import * as fs from 'fs';
+
+import { params } from './params.mjs';
+
+export function updatePackageJson() {
+
+  params.packageJsonObj.version = params.newSemver;
+  fs.writeFileSync(params.packageJsonFile, JSON.stringify(params.packageJsonObj, null, '  '));
+}

package/dev-tools/update-version/src/update-semver.mjs

@@ -0,0 +1,29 @@
+import { params } from './params.mjs';
+
+export function updateSemver() {
+  // Se stiamo solo inizializzando il log, la nuova versione è uguale alla vecchia
+  if (params.updateMode === 'init') {
+    params.newSemver = params.oldSemver;
+    return;
+  }
+
+  // ... logica esistente per major, minor, patch ...
+  if (params.semverArray.length < 3) while (params.semverArray.length < 3) params.semverArray.push(0);
+
+  switch (params.updateMode) {
+    case 'major':
+      params.semverArray[0]++;
+      params.semverArray[1] = 0;
+      params.semverArray[2] = 0;
+      break;
+    case 'minor':
+      params.semverArray[1]++;
+      params.semverArray[2] = 0;
+      break;
+    case 'patch':
+      params.semverArray[2]++;
+      break;
+  }
+
+  params.newSemver = params.semverArray.join('.');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massimo-cassandro/minimo",
-  "version": "1.8.4",
+  "version": "1.9.1",
   "description": "Light css framework & utilities",
   "type": "module",
   "main": "./index.js",
@@ -15,9 +15,16 @@
   "bugs": {
     "url": "https://github.com/massimo-cassandro/minimo/issues"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "bin": {
     "buildTokens": "./design-tokens/utilities/build-tokens.mjs",
-    "checkUnresolvedProps": "./design-tokens/utilities/check-unresolved-custom-props.mjs"
+    "checkUnresolvedProps": "./design-tokens/utilities/check-unresolved-custom-props.mjs",
+    "update-version": "./dev-tools/update-version/index.mjs",
+    "upd@m": "./dev-tools/upd@m/index.mjs",
+    "svgIconsTools": "./dev-tools/svg-icons-tools/index.mjs",
+    "create-favicons": "./dev-tools/create-favicons/index.mjs"
   },
   "repository": {
     "type": "git",
@@ -34,29 +41,40 @@
   },
   "license": "MIT",
   "author": "Massimo Cassandro",
-  "publishConfig": {
-    "access": "public"
-  },
   "sideEffects": [
     "**/s-datatable-component/**/*"
   ],
+  "engines": {
+    "node": ">= 18.0.0",
+    "npm": ">= 9.0.0"
+  },
   "files": [
     "./index.js",
     "src/**/*.{js,mjs,css,svg,md}",
     "design-tokens/tokens/**/*.{tokens.json,tokens.jsonc}",
     "design-tokens/_src/**/*.{tokens.json,tokens.jsonc,mjs,js,md}",
     "design-tokens/utilities/**/*.{mjs,md}",
-    "charts/**/*.{js,md}"
+    "charts/**/*.{js,md}",
+    "dev-tools/**/*.{js,mjs,md,html}"
   ],
   "peerDependenciesMeta": {
     "@svgdotjs/svg.js": {
       "optional": true
+    },
+    "style-dictionary": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@massimo-cassandro/dev-updater": "^3.0.7",
     "@massimo-cassandro/eslint-config": "^3.0.11",
     "@massimo-cassandro/stylelint-config": "^2.3.11",
     "style-dictionary": "^5.5.0"
+  },
+  "dependencies": {
+    "@inquirer/input": "^5.1.2",
+    "@inquirer/select": "^5.2.1",
+    "clipboardy": "^5.3.1",
+    "sharp": "^0.35.3",
+    "sharp-ico": "^0.1.5"
   }
 }

package/src/components/unsplash-page/fetch-unsplash-data.js

@@ -59,7 +59,7 @@ export async function fetchUnsplashData(settings) {
           width              : data.width,
           height             : data.height,
           // description        : data.description,
-          // location           : data.location.name,
+          // location           : data.location?.name,
           alt_description    : data.alt_description,
           date               : data.created_at,
           base_url           : data.urls.raw,
@@ -68,7 +68,7 @@ export async function fetchUnsplashData(settings) {
           author_profile     : data.user.links.html,
           blur_hash          : data.blur_hash,
           image_description  : (() => {
-            let location = data.location.name,
+            let location = data.location?.name,
               description = data.description?? data.alt_description;
             if(data.description && location) {
               location = (new RegExp(location, 'i')).test(description)? null : location;