@dative-gpi/foundation-shared-services 1.0.190 → 1.0.191-add-unit-formatter-2

package/composables/index.ts

@@ -5,4 +5,6 @@ export * from "./useDateFormat";
 export * from "./useFiles";
 export * from "./useFoundationShared";
 export * from "./useRouting";
-export * from "./useDateExpression";
+export * from "./useDateExpression";
+export * from "./useTimeDuration";
+export * from "./useUnitFormatter";

package/composables/useTimeDuration.ts

@@ -0,0 +1,75 @@
+import { TimeComparisonType } from "@dative-gpi/foundation-shared-domain/enums";
+import { useDateExpression } from "@dative-gpi/foundation-shared-services/composables";
+import { MILLISECONDS_PER_DAY, MILLISECONDS_PER_WEEK, MILLISECONDS_PER_MONTH_APPROX, MILLISECONDS_PER_YEAR_APPROX } from "@dative-gpi/foundation-shared-services/config";
+
+export const useTimeDuration = () => {
+    /**
+     * Computes the duration between two timestamps, in **milliseconds**.
+     *
+     * Returns `null` if:
+     * - `periodStart` or `periodEnd` is missing,
+     * - a timestamp cannot be converted to a number,
+     * - the end is equal to or before the start.
+     *
+     * @param periodStart Date fixe (ISO-8601) ou expression relative (ex: 'now-1h', 'now/d'), ou `undefined`.
+     * @param periodEnd Date fixe (ISO-8601) ou expression relative (ex: 'now', 'now-1d/d'), ou `undefined`.
+     * @returns Durée en millisecondes, ou `0` si l'expression est invalide ou si la fin est avant le début.
+     */
+    const getPeriodDuration = (periodStart: string | undefined, periodEnd: string | undefined): number | null => {
+        if (!periodStart || !periodEnd) {
+            return null;
+        }
+        const { convert } = useDateExpression();
+
+        const startTimestamp = convert(periodStart);
+        const endTimestamp = convert(periodEnd);
+
+        if (isNaN(startTimestamp) || isNaN(endTimestamp)) {
+            return null;
+        }
+
+        const durationMs = endTimestamp - startTimestamp;
+        return durationMs > 0 ? durationMs : null;
+    };
+
+    /**
+     * Returns the duration (in **milliseconds**) for a given {@link TimeComparisonType}.
+     *
+     * - `Daily` / `Weekly`: fixed constants.
+     * - `Monthly` / `Yearly`: **approximate** constants (not exact calendar lengths).
+     * - `SinceReference`: duration between `periodStart` and `periodEnd` (needed only for this mode).
+     * - `None` / `Absolute`: returns `null` (no implied fixed duration).
+     *
+     * @param timeframe Timeframe mode to convert into a duration.
+     * @param periodStart Optional start timestamp string (usually ISO-8601). Used only for `SinceReference`.
+     * @param periodEnd Optional end timestamp string (usually ISO-8601). Used only for `SinceReference`.
+     * @returns Duration in **milliseconds**.
+     */
+    const getTimeframeDuration = (timeframe: TimeComparisonType, periodStart: string | null = null, periodEnd: string | null = null): number | null => {
+        switch (timeframe) {
+            case TimeComparisonType.SinceReference:
+                return getPeriodDuration(periodStart ?? undefined, periodEnd ?? undefined);
+            case TimeComparisonType.Daily:
+                return MILLISECONDS_PER_DAY;
+            case TimeComparisonType.Weekly:
+                return MILLISECONDS_PER_WEEK;
+            case TimeComparisonType.Monthly:
+                return MILLISECONDS_PER_MONTH_APPROX;
+            case TimeComparisonType.Yearly:
+                return MILLISECONDS_PER_YEAR_APPROX;
+            case TimeComparisonType.None:
+                // No timeframe selected: no duration.
+                return null;
+            case TimeComparisonType.Absolute:
+                // Absolute comparisons do not imply a fixed duration.
+                return null;
+            default:
+                return null;
+        }
+    };
+
+    return {
+        getPeriodDuration,
+        getTimeframeDuration,
+    };
+}

package/composables/useUnitFormatter.ts

@@ -0,0 +1,201 @@
+import { useAppLanguageCode } from "@dative-gpi/foundation-shared-services/composables";
+import { SI_PREFIXES } from "@dative-gpi/foundation-shared-services/config/units";
+import { type UnitDefinition, unitRegistry } from "@dative-gpi/foundation-shared-domain/models";
+
+export function useUnitFormatter() {
+  const { languageCode } = useAppLanguageCode();
+
+  /**
+   * Converts a value from one unit to another of the same family
+   */
+  function convert(value: number, fromUnit: string, toUnit: string): number {
+    const sourceUnitDefinition = unitRegistry[fromUnit];
+    const targetUnitDefinition = unitRegistry[toUnit];
+    
+    if (!sourceUnitDefinition?.family || !targetUnitDefinition?.family) {
+      throw new Error(`Cannot convert between ${fromUnit} and ${toUnit}: missing family`);
+    }
+    
+    if (sourceUnitDefinition.family !== targetUnitDefinition.family) {
+      throw new Error(`Cannot convert between different families: ${sourceUnitDefinition.family} vs ${targetUnitDefinition.family}`);
+    }
+    
+    // Conversion via the pivot: pivot_value = sourceUnitDefinition_value * sourceUnitDefinition_factor
+    // targetUnitDefinition_value = pivot_value / targetUnitDefinition_factor
+    return (value * (sourceUnitDefinition.factor ?? 1)) / (targetUnitDefinition.factor ?? 1);
+  }
+
+  /**
+   * Finds the best unit in a family to display a value
+   * (the one that gives a result between 1 and 999)
+   */
+  function findBestUnit(value: number, currentUnit: string, fixedUnit?: string): string {
+    const unitDef = unitRegistry[currentUnit];
+    
+    if (!unitDef?.family) {
+      return currentUnit;
+    }
+
+    // Convert the value to the pivot (in absolute value)
+    const absoluteValueInPivot = Math.abs(value * (unitDef.factor ?? 1));
+    
+    // Find all units in the same family
+    const unitsInSameFamily = Object.entries(unitRegistry)
+      .filter(([, def]) => def.family === unitDef.family)
+      .map(([unit, def]) => ({
+        unit,
+        factor: def.factor ?? 1,
+        precision: def.precision,
+      }))
+      .sort((a, b) => a.factor - b.factor); // Sort by ascending factor
+
+    // Determine the maximum allowed factor
+    const maxFactor = fixedUnit && unitRegistry[fixedUnit]?.family === unitDef.family
+      ? unitRegistry[fixedUnit]?.factor ?? Infinity
+      : Infinity;
+
+    // Find the unit that gives a result >= 1 and < 1000
+    let bestUnit = unitsInSameFamily[0]?.unit ?? currentUnit; // Default: the smallest unit
+    
+    for (let i = unitsInSameFamily.length - 1; i >= 0; i--) {
+      const candidateUnit = unitsInSameFamily[i];
+      
+      // Do not exceed fixedUnit
+      if (candidateUnit.factor > maxFactor) {
+        continue;
+      }
+      
+      const valueInCandidateUnit = absoluteValueInPivot / candidateUnit.factor;
+      
+      // Find the unit that gives a result >= 1
+      if (valueInCandidateUnit >= 1) {
+        bestUnit = candidateUnit.unit;
+        break;
+      }
+    }
+    
+    return bestUnit;
+  }
+
+  /**
+   * Applies alternative conversions (non-family)
+   * These conversions take priority over the family system
+   */
+  function applyAlternativeConversions(value: number, unit: string, unitDefinition: UnitDefinition) {
+    if (!unitDefinition.conversions?.length) {
+      return { value, unit };
+    }
+
+    for (const conversion of unitDefinition.conversions) {
+      if (conversion.minThreshold != null && Math.abs(value) < conversion.minThreshold) {
+        continue;
+      }
+      
+      return { 
+        value: value * conversion.conversionRate, 
+        unit: conversion.targetUnit 
+      };
+    }
+
+    return { value, unit };
+  }
+
+  /**
+   * Applies SI prefixes for unknown units
+   */
+  function applySIScale(value: number, unit: string) {
+    const absoluteValue = Math.abs(value);
+    
+    let selectedPrefix = SI_PREFIXES[3]; // None
+    
+    for (let i = SI_PREFIXES.length - 1; i >= 0; i--) {
+      const currentPrefix = SI_PREFIXES[i];
+      
+      if (absoluteValue >= currentPrefix.factor) {
+        selectedPrefix = currentPrefix;
+        break;
+      }
+    }
+
+    return {
+      value: value / selectedPrefix.factor,
+      unit: `${selectedPrefix.prefix}${unit}`,
+    };
+  }
+
+  function formatNumber(value: number, decimalPrecision: number, locale?: string) {
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimalPrecision,
+    }).format(value);
+  }
+
+  const formatQuantity = (value: number, unit: string, options?: { decimalPrecision?: number; fixedUnit?: string; } ): string => {
+    if (!isFinite(value)) {
+      return "—";
+    }
+
+    const originalUnitDefinition = unitRegistry[unit];
+    let convertedResult: { value: number; unit: string };
+    let decimalPrecision: number;
+
+    if (originalUnitDefinition) {
+      convertedResult = applyAlternativeConversions(value, unit, originalUnitDefinition);
+      
+      const convertedUnitDefinition = unitRegistry[convertedResult.unit];
+      if (convertedUnitDefinition?.family) {
+        const bestUnit = findBestUnit(convertedResult.value, convertedResult.unit, options?.fixedUnit);
+        
+        if (bestUnit !== convertedResult.unit) {
+          convertedResult.value = convert(convertedResult.value, convertedResult.unit, bestUnit);
+          convertedResult.unit = bestUnit;
+        }
+      }
+      
+      decimalPrecision = options?.decimalPrecision ?? (unitRegistry[convertedResult.unit]?.precision ?? 2);
+    } else {
+      convertedResult = applySIScale(value, unit);
+      decimalPrecision = options?.decimalPrecision ?? 2;
+    }
+
+    const finalUnitSymbol = unitRegistry[convertedResult.unit]?.symbol ?? convertedResult.unit;
+    const formattedValue = formatNumber(convertedResult.value, decimalPrecision, languageCode.value);
+    
+    return `${formattedValue} ${finalUnitSymbol}`;
+  };
+
+  const formatQuantityParts = (value: number, unit: string, options?: { decimalPrecision?: number; fixedUnit?: string; } ): { value: string; unit: string } => {
+    
+    const fullFormattedQuantity = formatQuantity(value, unit, { decimalPrecision: options?.decimalPrecision,fixedUnit: options?.fixedUnit});
+    
+    if (fullFormattedQuantity === "—") {
+      return { 
+        value: "—", 
+        unit: "" 
+      };
+    }
+    
+    const indexOfLastSpace = fullFormattedQuantity.lastIndexOf(" ");
+    
+    if (indexOfLastSpace === -1) {
+      return { 
+        value: fullFormattedQuantity, 
+        unit: "" 
+      };
+    }
+
+    const valueWithoutUnit = fullFormattedQuantity.slice(0, indexOfLastSpace);
+    const unitOnly = fullFormattedQuantity.slice(indexOfLastSpace + 1);
+
+    return { 
+      value: valueWithoutUnit, 
+      unit: unitOnly 
+    };
+  };
+
+  return {
+    formatQuantity,
+    formatQuantityParts,
+    convert
+  };
+}

package/config/index.ts

@@ -1,2 +1,4 @@
 export * from "./literals";
+export * from "./timeDuration";
+export * from "./units";
 export * from "./urls";

package/config/timeDuration/index.ts

@@ -0,0 +1 @@
+export * from "./timePerPeriod";

package/config/timeDuration/timePerPeriod.ts

@@ -0,0 +1,4 @@
+export const MILLISECONDS_PER_DAY = 1000 * 60 * 60 * 24;
+export const MILLISECONDS_PER_WEEK = MILLISECONDS_PER_DAY * 7;
+export const MILLISECONDS_PER_MONTH_APPROX = MILLISECONDS_PER_DAY * 30;
+export const MILLISECONDS_PER_YEAR_APPROX = MILLISECONDS_PER_DAY * 365;

package/config/units/index.ts

@@ -0,0 +1 @@
+export * from "./unitPrefixes";

package/config/units/unitPrefixes.ts

@@ -0,0 +1,13 @@
+import { UnitPrefix } from "@dative-gpi/foundation-shared-domain/enums/units";
+
+export const SI_PREFIXES = [
+    { prefix: UnitPrefix.Nano, factor: 1e-9 },
+    { prefix: UnitPrefix.Micro, factor: 1e-6 },
+    { prefix: UnitPrefix.Milli, factor: 1e-3 },
+    { prefix: UnitPrefix.None, factor: 1 },
+    { prefix: UnitPrefix.Kilo, factor: 1e3 },
+    { prefix: UnitPrefix.Mega, factor: 1e6 },
+    { prefix: UnitPrefix.Giga, factor: 1e9 },
+    { prefix: UnitPrefix.Tera, factor: 1e12 },
+    { prefix: UnitPrefix.Peta, factor: 1e15 },
+];

package/package.json

@@ -4,7 +4,7 @@
     "url": "https://github.com/Dative-GPI/foundation-shared-ui.git"
   },
   "sideEffects": false,
-  "version": "1.0.190",
+  "version": "1.0.191-add-unit-formatter-2",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -13,7 +13,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "1.0.190",
+    "@dative-gpi/foundation-shared-domain": "1.0.191-add-unit-formatter-2",
     "@vueuse/core": "^14.0.0"
   },
   "peerDependencies": {
@@ -22,5 +22,5 @@
     "vue": "^3.4.38",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "c828caf6ee06215c92beb11d9cc8241f12d4abe0"
+  "gitHead": "7c34bcea5b12a9461c14adbdb2227f6dda0d46aa"
 }