@dative-gpi/foundation-shared-services 1.0.192 → 1.0.193-test-unit-formatter

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,230 @@
+import { useAppLanguageCode } from "@dative-gpi/foundation-shared-services/composables";
+import { SI_PREFIXES } from "@dative-gpi/foundation-shared-services/config/units";
+import { unitRegistry, unitFamilies, type UnitDefinition } from "@dative-gpi/foundation-shared-domain/models";
+
+export function useUnitFormatter() {
+  const { languageCode } = useAppLanguageCode();
+
+  function findBestSIPrefix(value: number): { prefix: string; factor: number } {
+    if (value === 0) {
+      return SI_PREFIXES[3];
+    }
+    
+    const absValue = Math.abs(value);
+    const magnitude = Math.floor(Math.log10(absValue) / 3) * 3;
+    
+    const prefixIndex = Math.floor((magnitude + 9) / 3);
+    
+    return SI_PREFIXES[Math.max(0, Math.min(prefixIndex, SI_PREFIXES.length - 1))];
+  }
+
+  function parseUnitWithPrefix(unitString: string): { prefix: string; baseUnit: string } {
+    const s = unitString.trim();
+
+    // 1) Priorité au match exact (évite "m" => prefix "m" + base "")
+    //    et évite "Pa" => prefix "P" + base "a"
+    if (unitRegistry[s]) {
+      return { prefix: "", baseUnit: s };
+    }
+
+    // 2) Préfixes SI (sans ""), du plus long au plus court (robuste si un jour tu ajoutes "da")
+    const prefixes = SI_PREFIXES
+      .map(p => p.prefix)
+      .filter(p => p !== "")
+      .sort((a, b) => b.length - a.length);
+
+    // 3) On n'accepte un préfixe que si le reste est une unité connue du registry
+    for (const prefix of prefixes) {
+      if (!s.startsWith(prefix)) {continue;}
+
+      const baseUnit = s.slice(prefix.length);
+      if (!baseUnit) {continue;}
+
+      if (unitRegistry[baseUnit]) {
+        return { prefix, baseUnit };
+      }
+    }
+
+    // 4) Aucun préfixe valide détecté => on garde l'unité telle quelle
+    return { prefix: "", baseUnit: s };
+  }
+
+
+  function findPrefixByName(prefixName: string): { prefix: string; factor: number } | null {
+    const found = SI_PREFIXES.find(p => p.prefix === prefixName);
+    return found || null;
+  }
+
+  function convertWithinFamily(value: number, fromUnit: string, toUnit: string): number {
+    const from = unitRegistry[fromUnit];
+    const to = unitRegistry[toUnit];
+    
+    if (!from || !to) {
+      throw new Error(`Unknown units: ${fromUnit} or ${toUnit}`);
+    }
+    
+    if (from.family !== to.family) {
+      throw new Error(`Different families: ${from.family} vs ${to.family}`);
+    }
+    
+    return (value * from.toPivot) / to.toPivot;
+  }
+
+
+  function applySpecialConversions(value: number, unit: string, unitDefinition: UnitDefinition ): { value: number; unit: string } {
+    if (!unitDefinition.specialConversions?.length) {
+      return { value, unit };
+    }
+    
+    for (const conversion of unitDefinition.specialConversions) {
+      if (Math.abs(value) >= conversion.threshold) {
+        const convertedValue = convertWithinFamily(value, unit, conversion.toUnit);
+
+        return { value: convertedValue, unit: conversion.toUnit };
+      }
+    }
+    
+    return { value, unit };
+  }
+
+  function selectBestUnit(value: number, unit: string, unitPrecision?: string): { value: number; unit: string; symbol: string; } {
+    const unitSourceDefinition = unitRegistry[unit];
+    
+    // Unknown unit : apply SI prefixes only
+    if (!unitSourceDefinition) {
+      const prefix = findBestSIPrefix(value);
+      const scaledValue = value / prefix.factor;
+      return {
+        value: scaledValue,
+        unit: `${prefix.prefix}${unit}`,
+        symbol: `${prefix.prefix}${unit}`
+      };
+    }
+    
+    // if unitPrecision is specified and valid
+    if (unitPrecision) {
+      const parsed = parseUnitWithPrefix(unitPrecision);
+      const precisionUnitDefinition = unitRegistry[parsed.baseUnit];
+      
+      if (precisionUnitDefinition && precisionUnitDefinition.family === unitSourceDefinition.family) {
+        // Convert value to the precision unit
+        const valueInPrecision = convertWithinFamily(value, unit, parsed.baseUnit);
+        
+        // If a prefix is specified in unitPrecision, apply it EXACTLY
+        if (parsed.prefix) {
+          const forcedPrefix = findPrefixByName(parsed.prefix);
+          if (forcedPrefix) {
+            const scaledValue = valueInPrecision / forcedPrefix.factor;
+            return {
+              value: scaledValue,
+              unit: parsed.baseUnit,
+              symbol: `${forcedPrefix.prefix}${precisionUnitDefinition.symbol}`,
+            };
+          }
+        }
+        
+        // No prefix specified in unitPrecision: return WITHOUT any SI prefix
+        return {
+          value: valueInPrecision,
+          unit: parsed.baseUnit,
+          symbol: precisionUnitDefinition.symbol,
+        };
+      }
+    }
+    
+    // Apply special conversions
+    const afterSpecial = applySpecialConversions(value, unit, unitSourceDefinition);
+    if (afterSpecial.unit !== unit) {
+      return selectBestUnit(afterSpecial.value, afterSpecial.unit, unitPrecision);
+    }
+    
+    // if the unit support SI prefix
+    if (unitSourceDefinition.usesSIPrefixes) {
+      const prefix = findBestSIPrefix(value);
+      const scaledValue = value / prefix.factor;
+      return {
+        value: scaledValue,
+        unit,
+        symbol: `${prefix.prefix}${unitSourceDefinition.symbol}`,
+      };
+    }
+    
+    return {
+      value,
+      unit,
+      symbol: unitSourceDefinition.symbol,
+    };
+  }
+
+  function formatNumber(value: number, precision: number, locale?: string): string {
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: precision,
+    }).format(value);
+  }
+
+  /**
+   * take a value with its source unit, convert it to targetUnit (if specified),
+   * find the best SI prefix (unless unitPrecision is specified),
+   * and format it as a string.
+   */
+  function formatQuantity(valueToConvert: number, sourceUnit: string, options?: { targetUnit?: string; unitPrecision?: string; decimalPrecision?: number; }): 
+  { formatted: string;
+    value: string;
+    unit: string;
+  } {
+    if (!isFinite(valueToConvert)) {
+      return {
+        formatted: "—",
+        value: "—",
+        unit: ""
+      };
+    }
+    
+    const sourceUnitDef = unitRegistry[sourceUnit];
+    let finalValue = valueToConvert;
+    let finalUnit = sourceUnit;
+    
+    if (options?.targetUnit && options.targetUnit !== sourceUnit) {
+      const targetUnitDef = unitRegistry[options.targetUnit];
+      
+      if (!sourceUnitDef || !targetUnitDef) {
+        throw new Error(`Unknown unit: ${sourceUnit} or ${options.targetUnit}`);
+      }
+      
+      // Conversion with custom function (temperatures)
+      const family = unitFamilies[sourceUnitDef.family];
+      if (family.customConverter) {
+        finalValue = family.customConverter(valueToConvert, sourceUnit, options.targetUnit);
+        finalUnit = options.targetUnit;
+      }
+      // Conversion between units of the same family
+      else if (sourceUnitDef.family === targetUnitDef.family) {
+        finalValue = convertWithinFamily(valueToConvert, sourceUnit, options.targetUnit);
+        finalUnit = options.targetUnit;
+      }
+      // Different families: error
+      else {
+        throw new Error(`Cannot convert between ${sourceUnitDef.family} and ${targetUnitDef.family}`);
+      }
+    }
+    
+    // Find the best prefix
+    const result = selectBestUnit(finalValue, finalUnit, options?.unitPrecision);
+    
+    const decimalPrecision = options?.decimalPrecision ?? 2;
+    
+    const formattedValue = formatNumber(result.value, decimalPrecision, languageCode.value);
+    const formatted = `${formattedValue} ${result.symbol}`;
+    
+    return {
+      formatted,
+      value: formattedValue,
+      unit: result.symbol
+    };
+  }
+
+  return {
+    formatQuantity
+  };
+}

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.192",
+  "version": "1.0.193-test-unit-formatter",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -13,7 +13,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "1.0.192",
+    "@dative-gpi/foundation-shared-domain": "1.0.193-test-unit-formatter",
     "@vueuse/core": "^14.0.0"
   },
   "peerDependencies": {
@@ -22,5 +22,5 @@
     "vue": "^3.4.38",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "ee4d3a1f2581f8fc1765618f7b7b0aeb6368a0b2"
+  "gitHead": "fc948d90c3e19270003dc7f695459ae96bf1539c"
 }