@dative-gpi/foundation-shared-services 1.0.193-test-unit-formatter → 1.0.193-value-data-composable

package/composables/index.ts

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

package/config/index.ts

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

package/package.json

@@ -4,7 +4,7 @@
     "url": "https://github.com/Dative-GPI/foundation-shared-ui.git"
   },
   "sideEffects": false,
-  "version": "1.0.193-test-unit-formatter",
+  "version": "1.0.193-value-data-composable",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -13,7 +13,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "1.0.193-test-unit-formatter",
+    "@dative-gpi/foundation-shared-domain": "1.0.193-value-data-composable",
     "@vueuse/core": "^14.0.0"
   },
   "peerDependencies": {
@@ -22,5 +22,5 @@
     "vue": "^3.4.38",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "fc948d90c3e19270003dc7f695459ae96bf1539c"
+  "gitHead": "e6d7d1fd7a3bc060cebb335596f4d95a6ce91356"
 }

package/composables/useUnitFormatter.ts

@@ -1,230 +0,0 @@
-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/units/index.ts

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

package/config/units/unitPrefixes.ts

@@ -1,13 +0,0 @@
-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 },
-];