@massimo-cassandro/minimo 1.18.1 → 1.18.2

package/charts/TODO charts/1a-vers DA RIFATTORIZZARE/src/charts/settimanale-mensile-src/parse-opts.js

@@ -0,0 +1,64 @@
+// prima elaborazione e controlli delle impostazioni
+
+import { getWeekOfDate } from '../../week-utils.js';
+
+
+export function parseOpts(cfg) {
+
+  try {
+
+    if(+cfg.width < 100 || +cfg.height < 100) {
+      throw '`width` e/o `height` mancanti o di dimensioni insufficienti (devono essere maggiori di 99px)';
+    }
+
+    if(!['settimanale', 'mensile'].includes(cfg.modo)) {
+      throw `‘modo’ deve essere ‘settimanale’ o ‘mensile’ (valore attuale: ‘${cfg.modo}’)`;
+    }
+    cfg.isSettimanale = cfg.modo === 'settimanale';
+
+
+    // =>> PARAMETRI  calcolati
+    //---------------
+
+    // solo settimanale
+    if(cfg.isSettimanale) {
+
+      // calcolo max_value (tiene conto della eventuale esclusione della settimana zero)
+      cfg.max_value = cfg.chartData.filter(row => cfg.skipWeek0? row.w > 0 : true).reduce((prev, curr) => {
+        return Math.max(prev, ...Object.values(curr));
+      }, 0);
+
+      // aggiustamento `eti_asseX_cfg.height` per fare spazio alle etichette con il nome dei mesi
+      cfg.eti_asseX_height *= 2.2;
+    }
+
+    cfg.currentWeek = getWeekOfDate({year: cfg.anno});
+    cfg.currentMonth = new Date().getMonth() + 1; // base 1
+
+    // primo dell'anno
+    cfg.jan1 = new Date(Date.UTC(cfg.anno, 0, 1));
+    cfg.jan1DayOfTheWeek = cfg.jan1.getDay();
+
+    // il numero di settimane dell'anno non include la settimana 0, se presente,
+    // che indica il riporto anno precedente.
+    // se il 31 dicembre è prima di giovedì, viene considerato nella prima settimana dell'anno successivo
+    // e il numero di settimane dell'anno è 52
+    cfg.dec31WeekNum = getWeekOfDate({date: new Date(cfg.anno, 11, 31), year: cfg.anno});
+    cfg.weeks = cfg.dec31WeekNum === 1? 52 : cfg.dec31WeekNum;
+
+    cfg.mesi = ['Gen', 'Feb', 'Mar', 'Apr', 'Mag', 'Giu', 'Lug', 'Ago', 'Set', 'Ott', 'Nov', 'Dic'];
+
+    // larghezza ogni step dell'asse X (= 1 settimana o mese)
+    if(cfg.isSettimanale) {
+      cfg.stepX_count = cfg.weeks + (cfg.skipWeek0? 0 : 1);
+    } else {
+      cfg.stepX_count = 12;
+    }
+
+
+    return cfg;
+
+  } catch(e) {
+    console.error( 'AdaCharts → andamentoAnnuale → parseOpts', e ); // eslint-disable-line
+  }
+}

package/charts/TODO charts/1a-vers DA RIFATTORIZZARE/src/charts/settimanale-mensile-src/paths-setup.js

@@ -0,0 +1,73 @@
+// elaborazione dati grafico, costruzione coordinate paths e punti
+
+export function pathsSetup(cfg) {
+
+  // coordinate dei punti dei vari set di dati
+  // array delle varie serie di punti che saranno poi utilizzate per costruire gli elementi del grafico
+  // ogni elemento dell'array contiene le coordinate x,y di ogni punto
+  cfg.coords = {
+    budget_standard: [],
+    budget_positivo: [],
+    budget_negativo: [],
+    consolidato: [],
+    consolidato_forecast: [],
+    consolidato_prec: []
+  };
+
+  // step iniziale o 1 se skipWeek0 = true e modo = 'settimanale'
+  const firstStep = (cfg.skipWeek0 && cfg.isSettimanale)? 1 : 0
+
+    // conversione valori in coordinate Y relative al grafico
+    ,valueToY = (value) => {
+      // la coordinata y è ricavata dalla proporzione con il valore massimo e altezza del grafico
+      // arrotondata a 4 cifre decimali
+
+      // return  chart_area.top + chart_area.height - ((value * chart_area.height) / max_value);
+      return Math.round(
+        (cfg.chart_area.top + cfg.chart_area.height - ((value * cfg.chart_area.height) / cfg.max_value)) * 1e4
+      ) / 1e4;
+
+    }
+  ;
+
+  // valore x iniziale
+  let x = cfg.chart_area.left;
+
+  for (let thisStep = firstStep; thisStep <= cfg.stepX_count; thisStep++) {
+
+    const dataItem = cfg.chartData.filter(row => row[cfg.isSettimanale? 'w' : 'm'] === thisStep )[0] ?? {};
+
+    /**
+      {
+        w: <num>,   // numero settimana (se settimanale)
+        m: <num>,   // numero mese (se mensile)
+
+        s: <num>,   // valore scenario standard
+        p: <num>,   // valore scenario positivo
+        n: <num>,   // valore scenario negativo
+        c: <num>,   // valore consolidato anno corrente (può essere null)
+        cp: <num>,   // valore consolidato anno precedente
+        cf: <num>    // valore consolidato forecast (può non essere presente o null)
+      }
+    */
+
+    // ['s', 'p', 'n', 'c', 'cp', 'cf'].forEach(k => {
+    //   if(dataItem[k] != null) {
+    //     cfg.coords.budget_standard.push([x, valueToY(dataItem[k] ?? 0)]);
+    //   }
+    // });
+
+    if(dataItem.p != null) cfg.coords.budget_positivo.push([x, valueToY(dataItem.p)]);
+    if(dataItem.n != null) cfg.coords.budget_negativo.push([x, valueToY(dataItem.n)]);
+    if(dataItem.s != null) cfg.coords.budget_standard.push([x, valueToY(dataItem.s)]);
+    if(dataItem.c != null) cfg.coords.consolidato.push([x, valueToY(dataItem.c)]);
+    if(dataItem.cf != null) cfg.coords.consolidato_forecast.push([x, valueToY(dataItem.cf)]);
+    if(dataItem.cp != null) cfg.coords.consolidato_prec.push([x, valueToY(dataItem.cp)]);
+
+    x += +cfg.stepX_size;
+    x = +x.toFixed(4);
+
+  } // end for step x
+
+  return cfg;
+}

package/charts/TODO charts/1a-vers DA RIFATTORIZZARE/src/charts/settimanale-mensile.js

@@ -0,0 +1,126 @@
+/**
+ *
+ * Grafico andamento economico annuale
+ * produce un grafico a linee con l'andamento annuale di un determinato parametro
+ * con dettagli settimanali o mensili
+ */
+
+// vedi test per la definizione delle opzioni
+
+// TODO metodo migliore per condivisione variabili
+// TODO parte interattiva
+
+import { parseStdAxisOpts } from '../components/parse-std-axis-opts.js';
+
+import { costruzioneAssi } from './settimanale-mensile-src/costruzione-assi.js';
+import { default_opts } from './settimanale-mensile-src/defaults.js';
+import { parseOpts } from './settimanale-mensile-src/parse-opts.js';
+import { pathsSetup } from './settimanale-mensile-src/paths-setup.js';
+import { gridAreas } from './settimanale-mensile-src/grid-areas.js';
+import { displayCurrent } from './settimanale-mensile-src/display-current.js';
+import { costruzioneLinee } from './settimanale-mensile-src/costruzione-linee.js';
+
+
+export async function settimanaleMensile(options) {
+
+  // =>> parse container
+  [options.container, options.width, options.height] = this.utils.parseContainer(options.container, options.width, options.height);
+
+  let cfg = {...default_opts, ...options};
+
+  cfg.debug = this.debug? this.debug : (cfg.debug?? false);
+
+
+  // =>> prima elaborazione e controlli delle impostazioni
+  cfg = parseOpts(cfg); // elaborazione specifica per questo grafico
+
+
+  if(!cfg.container && (!cfg.width || !cfg.height)) {
+    throw '`container` non impostato e almeno uno tra `width` e `height` mancante';
+  }
+  // valore massimo da rappresentare
+  // se `skipWeek0 === true`, i dati della settimana zero non vanno inclusi nel calcolo
+
+  cfg.max_value = cfg.chartData
+    .filter(weekData => cfg.skipWeek0 === true? weekData.w > 0 : true)
+    .reduce((prev, curr) => {
+      return Math.max(prev, ...Object.values(curr));
+    }, 0);
+
+  const parsed_cfg = parseStdAxisOpts({ // elaborazione standard condivisa con grafici analoghi
+    max_value: cfg.max_value,
+    values: cfg.chartData.map(item => Object.values(item)).flat(),
+    legenda: cfg.legenda,
+    padding: cfg.padding,
+    width: cfg.width,
+    height: cfg.height,
+    eti_asseX_height: cfg.eti_asseX_height,
+    eti_asseY_width: cfg.eti_asseY_width,
+    stepY_count: cfg.stepY_count,
+    stepX_count: cfg.stepX_count,
+    ticksLength: cfg.ticksLength,
+  });
+  cfg = {...cfg, ...parsed_cfg};
+
+
+  // =>> svg
+  cfg.svgCanvas = this.createSvgCanvas(cfg.container, cfg.debug)
+    .size(cfg.width, cfg.height)
+    .viewbox(0, 0, cfg.width, cfg.height)
+    .attr(cfg.svgAttrs??{});
+
+
+  // =>> elaborazione dati grafico, costruzione coordinate paths e punti
+  cfg = pathsSetup(cfg);
+
+
+  // =>> costruzione assi e griglia
+  cfg = await costruzioneAssi({
+    cfg: cfg,
+    adaChartIstance: this,
+    xLabels: cfg.isSettimanale? [...Array(cfg.weeks + 1).keys()].slice(cfg.skipWeek0? 1 : 0) : cfg.mesi,
+  });
+
+  // =>> aree colorate per l'evidenziazione dei mesi e seconda riga di etichette
+  // solo settimanale
+  if(cfg.isSettimanale) {
+    cfg = await gridAreas(cfg, this);
+  }
+
+  // =>> costruzione linee
+  cfg = costruzioneLinee(cfg);
+
+  // =>> evidenziazione settimana / mese corrente
+  cfg = displayCurrent(cfg);
+  cfg.lineeGroup.front();
+
+  // =>> Legenda
+  const legendaEl = await this.legenda(cfg.legenda);
+  legendaEl.attr({ 'data-cfg.debug-info': cfg.debug? 'Legenda' : null });
+  const legendaBbox = legendaEl.bbox();
+
+  legendaEl.dmove(
+    (cfg.width - legendaBbox.width) / 2,
+    cfg.padding
+  );
+  legendaEl.y(cfg.padding);
+
+  legendaEl.x((cfg.width - legendaBbox.width) / 2);
+
+  cfg.svgCanvas.add(legendaEl);
+
+  if(!cfg.container) {
+    return cfg.svgCanvas.svg();
+  }
+
+  if(cfg.debug) {
+
+    /* eslint-disable no-console */
+    console.log('\n****** grafico andamento annuale ******');
+    console.log(cfg);
+    console.log('************');
+    /* eslint-enable no-console */
+  }
+
+}
+

package/charts/TODO charts/1a-vers DA RIFATTORIZZARE/src/charts/signal-bars.js

@@ -0,0 +1,290 @@
+/**
+ * signal bars (grafico a tacche)
+ *
+ * Mostra una serie di barre analoghe a quelle del segnale dei cellulari
+ * in cui le barre vengono mostrate attive se il valore di riferimento è maggiore o uguale
+ * a uno degli indici del range dato e inferiore al successivo.
+ * Di conseguenza, se il valore di riferimento è più basso del valore minimo del range
+ */
+
+
+export async function signalBars({
+
+
+  /** container (selettore o elemento DOM), se null viene restituito il codice SVG */
+  container = null,
+
+  /**
+    larghezza e altezza del grafico (px),
+    Se il container è presente e i parametro `width` e `height` sono `null`,
+    vengono utilizzate le dimensioni  del container.
+    Se uno dei due valori non è impostato o ricavabile, viene generato un errore.
+    NB: il padding del container viene considerato nelle dimensioni del grafico,
+    è preferibile non impostarlo.
+    Il valore 'auto' di height fa sì che l'altezza dell'svg sia calcolata sulla base
+    del numero di barre e dei valori `barsGap` e `barsHeight`
+  */
+  width = null, // null || <value>
+  height = 300, // <value> || null
+
+  /**
+    range di valori che corrispondono alle varie tacche,
+    un valore inferiore al primo non "accende" nessuna tacca,
+    tra il primo (incluso), e il secondo (escluso), una tacca e così via.
+    Il numero di elementi determina il numero delle tacche
+  */
+  ranges = [1,2,3,4],
+
+  /**
+    se fornito, le barre 'accese' non vengono calcolate, ma si uutilizza questo valore
+    corrisponde al numero di barre attivate da sinistra verso destra.
+    Se presente, `value` può essere omesso ed è comunque ignorato
+  */
+  activeBars = null,
+
+  /** Valore da rappresentare */
+  value = null,
+
+  /**
+    etichetta da mostrare a destra o sotto le tacche. Se nulla mostra il valore di `value`,
+    stringa vuota o false per non avere etichetta
+  */
+  label = null,
+
+
+  /** posizione dell'etichetta */
+  labelPosition = 'right', // right o bottom
+
+  /**
+    Impostazioni font e colori per le etichette
+    Impostare solo se non si vogliono usare i colori di default
+    se impostato, è un oggetto analogo a quello definito in src/utils/init.js
+  */
+  labelFont = null,
+  labelFill = '#000',
+
+  /** path del file font per la conversione in tracciati */
+  labelFontFilePath = null,
+
+  /** spazio tra l'etichetta e il grafico */
+  textBarsGap = 8,
+
+  /** spazio tra una barra e la successiva */
+  barsGap = 10,
+
+  /** corner radius */
+  barsCornerRadius = 3,
+
+  /**
+    come il precedente, ma relatuvo alla larghezza della barra,
+    ad esempio un valore di `.5' crea della barre dalle estremità tonde
+    Se presente, il valore di `barsCornerRadius` viene ignorato
+  */
+  barsRelativeCornerRadius = null,
+
+  /**
+    attributi barre attive e disattive
+    ad esclusione di `stroke-width` da gestire separatamente con barsStrokeWidth per esigenze di calcolo
+    vedi https://svgjs.dev/docs/3.2/manipulating/#attributes
+  */
+  barsStrokeWidth = 3,
+  barsOnAttr = {
+    fill: '#000'
+    // ,'fill-opacity': 0.5
+    ,stroke: '#000'
+    ,'stroke-width': 3
+  },
+  barsOffAttr = {
+    fill: '#000'
+    // ,'fill-opacity': 0.5
+    ,stroke: '#fff'
+    ,'stroke-width': 3
+  },
+
+  /** seimpostato, il valore massimo della larghezz delle barre */
+  maxBarWidth = null,
+
+  /** eventuali classi da aggiungere al grafico */
+  svgClassName = null,
+  labelClassName = null,
+  barOnClassName = null,
+  barOffClassName = null,
+
+
+} = {}) {
+
+  try {
+
+
+    if(ranges.filter(v => isNaN(v)).length) {
+      throw 'There are non-numeric values';
+    }
+
+    if(ranges.length < 2) {
+      throw '`ranges`: sono necessari alemno due valori';
+    }
+
+    if(typeof barsStrokeWidth !== 'number') {
+      throw '`barsStrokeWidth` deve essere un numero';
+    }
+
+    if((value == null || typeof value !== 'number') && (activeBars == null || typeof activeBars !== 'number')) {
+      throw 'Almeno uno tra `value` e `activeBars` deve essere presente e deve essere un numero ' +
+        `(value: ${value}, activeBars: ${activeBars})`;
+    }
+
+    if(!['right', 'bottom'].includes(labelPosition)) {
+      throw '`labelPosition` deve essere`right` o `bottom`';
+    }
+
+    // container
+    [, width, height] = this.utils.parseContainer(container, width, height);
+
+
+    if(barsGap == null) {
+      throw '`barsGap` deve essere impostato';
+    }
+
+
+    if(!width || !height) {
+      throw `width e/o height mancanti: width: ${width}, height: ${height}`;
+    }
+
+    const svgCanvas = this.createSvgCanvas(container).size(width, height);
+    svgCanvas.viewbox(0, 0, width, height);
+
+    if(svgClassName) {
+      svgCanvas.addClass(svgClassName);
+    }
+
+    let labelX, labelY, barsAreaWidth, barWidth, barsAreaHeight, labelEl, label_bbox;
+    const barsCount = ranges.length;
+
+    if(label !== '' && label !== false) {
+
+      if(label == null) {
+        label = value.toLocaleString('it-IT', { maximumFractionDigits: 2 });
+      }
+
+      // =>> calcolo dimensioni del testo per ricavare lo spazio utile per le barre
+      // in base al posizionamento dell'etichetta
+
+      // =>> label
+      [label_bbox, labelEl] = await this.createTextEl ({
+        text: label,
+        textFill: labelFill,
+        fontAttr: labelFont,
+        fontFilePath: labelFontFilePath,
+        parentElement: svgCanvas
+      });
+
+
+      if(labelPosition === 'right') {
+        labelX = width - label_bbox.width;
+        labelY = (height - label_bbox.height) / 2;
+        barsAreaWidth = width - label_bbox.width - textBarsGap;
+        barsAreaHeight = height;
+
+      } else {
+        labelX = (width - label_bbox.width) / 2;
+        labelY = height - label_bbox.height;
+        barsAreaWidth = width;
+        barsAreaHeight = height - label_bbox.height - textBarsGap;
+      }
+
+      // posizionamento etichetta
+      labelEl.move(labelX, labelY);
+
+      if(labelClassName) {
+        labelEl.addClass(labelClassName);
+      }
+
+
+    } else {
+      barsAreaWidth = width;
+      barsAreaHeight = height;
+    }
+
+    barWidth = (
+      barsAreaWidth -
+      (barsGap * (barsCount - 1)) -
+      ((barsStrokeWidth?? 0) * barsCount) // lo spessore della traccia è divisa tra interno ed esterno
+    ) / barsCount;
+    barWidth = Math.min(maxBarWidth?? Infinity, barWidth);
+
+    const barsMaxHeight = barsAreaHeight - (barsStrokeWidth?? 0),
+      barsModuleHeight = barsMaxHeight / barsCount;
+
+
+    // coordinate x e y e altezza della prima barra
+    let barX = (
+        barsAreaWidth -
+        (barWidth * barsCount) -
+        (barsGap * (barsCount - 1)) -
+        ((barsStrokeWidth?? 0) * barsCount)
+      ) / 2 + ((barsStrokeWidth?? 0)/2),
+      barHeight = barsModuleHeight,
+      barY = barsAreaHeight - barHeight - ((barsStrokeWidth?? 0) / 2);
+
+
+    // indice dell'ultima barra da rappresentare con riempimento attivo
+    ranges.sort((a,b) => a - b);
+    let lastActiveBarIndex;
+
+    if(activeBars) {
+      lastActiveBarIndex = activeBars - 1;
+
+    } else {
+      const closestRangeValue = ranges.reduce((prev, curr) => {
+        return (Math.abs(Math.ceil(curr - value)) < Math.abs(Math.ceil(prev - value)) ? curr : prev);
+      });
+      lastActiveBarIndex = ranges.indexOf(closestRangeValue);
+    }
+
+    const bar_group = svgCanvas.group();
+
+    ranges.forEach((val, idx) => {
+
+      const barIsOn = idx <= lastActiveBarIndex;
+
+      const bar = bar_group.rect({
+        x: barX,
+        y: barY,
+        width: barWidth,
+        height: barHeight,
+        ...(barIsOn? barsOnAttr : barsOffAttr),
+      });
+
+      if(barsRelativeCornerRadius != null || barsCornerRadius != null) {
+
+        barsCornerRadius= barsRelativeCornerRadius != null? barWidth/2 : barsCornerRadius;
+
+        bar.radius(barsCornerRadius);
+      }
+
+      if( barsStrokeWidth > 0 ) {
+        bar.stroke({ width: barsStrokeWidth });
+      }
+
+      if(barOnClassName && barIsOn) {
+        bar.addClass(barOnClassName);
+      }
+      if(barOffClassName && !barIsOn) {
+        bar.addClass(barOffClassName);
+      }
+
+      barHeight += barsModuleHeight;
+      barX += barWidth + barsStrokeWidth + barsGap;
+      barY -= barsModuleHeight;
+    });
+
+    if(!container) {
+      return svgCanvas.svg();
+    }
+
+
+  } catch(e) {
+    console.error( 'AdaCharts → signalBars', e ); // eslint-disable-line
+  }
+
+}

package/charts/TODO charts/1a-vers DA RIFATTORIZZARE/src/week-utils.js

@@ -0,0 +1,122 @@
+
+/**
+ * Restituisce il numero della settimana corrente
+ * se la prima settimana ha meno di 4 gg e viene quindi assegnata all'ultima dell'anno precedente
+ * i giorni relativi vengono aggiunti alla prima settimana (che così ha più di 7 giorni)
+ * discorso analogo per l'ultima settimana
+ *
+ * @param {date} date
+ * @param {number} year
+ * @returns Number
+ */
+
+
+export function getWeekOfDate({date = new Date(), year = null}) {
+
+  // se year è null, si considera quello della data indicata
+  if(year == null) {
+    year = date.getFullYear();
+  }
+
+  // se la data non è nell'anno indicato, viene restituito null
+  if(date.getFullYear() !== year) {
+    return null;
+  }
+
+  const dateMonth = date.getMonth(); // necessario congelarlo, date viene modificata più volte
+
+  date.setHours(0, 0, 0, 0);
+
+  // Thursday in current week decides the year.
+  date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
+  // January 4 is always in week 1.
+  let week1 = new Date(date.getFullYear(), 0, 4);
+  // Adjust to Thursday in week 1 and count number of weeks from date to week1.
+  let currentWeek =  1 + Math.round(
+    ((date.getTime() - week1.getTime()) / 86400e3 - 3 + (week1.getDay() + 6) % 7) / 7
+  );
+
+  // prima settimana con meno di 4 giorni, normalmente sarebbe calcolata nell'anno precedente
+  // ma in questo caso i giorni relativi vengono aggiunti alla prima settimana del nuovo anno
+  if(currentWeek >= 52 && dateMonth === 0) {
+    currentWeek = 1;
+  }
+
+  return currentWeek;
+
+}
+
+
+/**
+ * Restituisce le date di inizio e fine della settimana dell'anno dati
+ *
+ * @param {number} week
+ * @param {number} year
+ * @returns Array
+ */
+export function getDatesOfWeek(week, year) {
+  if(week) {
+
+    let startDay, endDay;
+
+    const jan1 = new Date(Date.UTC(year, 0, 1, 0, 0, 0))
+      , jan1DayOfTheWeek = jan1.getDay()
+      // primo lunedì dell'anno
+      , daysToFirstMonday = jan1DayOfTheWeek === 1? 0 : jan1DayOfTheWeek === 0? 1 :  8 - jan1DayOfTheWeek
+      , firstMonday = daysToFirstMonday === 0 ? jan1 : new Date(+jan1 + daysToFirstMonday * 86400e3)
+      , dec31 = new Date(Date.UTC(year, 11, 31))
+      , lastDayOfThisWeek = new Date(+firstMonday + ((week - 1) * 7 * 86400e3) + (86400e3 * 6) )
+      , __weeks = 52 // ricavato dalla 'array dati, qui è usato un valore fittizio
+    ;
+
+    // console.log('jan1', jan1.toUTCString());
+    // console.log('jan1DayOfTheWeek', jan1DayOfTheWeek);
+    // console.log('daysToFirstMonday', daysToFirstMonday);
+    // console.log('firstMonday', firstMonday.toUTCString());
+    // console.log('dec31', dec31.toUTCString());
+    // console.log('lastDayOfThisWeek', lastDayOfThisWeek.toUTCString());
+
+
+    // forza il primo giorno della prima settimana al 1 gennaio anche se non è lunedì
+    if(week === 1) {
+      startDay = jan1;
+    } else {
+      startDay = new Date(firstMonday.valueOf());
+      startDay = new Date(startDay.setDate(startDay.getDate() + 7 * (week - 2)));
+    }
+
+    // prima settimana con più di 4 gg, viene considerata a se stante
+    endDay = new Date(startDay.valueOf());
+    if(week === 1 && jan1DayOfTheWeek < 5) {
+      endDay = new Date(endDay.setDate(endDay.getDate() + 7 - jan1DayOfTheWeek));
+    } else {
+      endDay = new Date(endDay.setDate(endDay.getDate() + 6));
+    }
+
+    // forza l'ultmo giorno dell'ultima settimana al 31 dic anche se non è domenica
+    if(endDay.getFullYear() > year || week === __weeks) {
+      endDay = dec31;
+    }
+
+
+
+    // nel caso in cui la settimana sia la prima o l'ultima,viene restituito un terzo elemento
+    // a indicare, rispettivamente, se 1 gennaio corrisponde all'inizione reale della 1a settimana
+    // o se 31 dic corrisponde all'ultimo giorno dell'ultima settimana
+
+    if(week === 1) {
+      return [startDay, endDay, +firstMonday === +jan1];
+
+    } else if (week === __weeks) {
+      return [startDay, endDay, +dec31 === +lastDayOfThisWeek];
+
+    } else {
+      return [startDay, endDay];
+    }
+
+  } else {
+    return null;
+  }
+
+
+}