@dative-gpi/foundation-shared-components 1.0.69 → 1.0.71-groupings-2

package/utils/operations.ts

@@ -0,0 +1,108 @@
+const MinusOperator = "-";
+
+/**
+ * Splits an expression by operators while keeping unary minus signs.
+ */
+const splitByOperators = (expression: string): string[] => {
+  const tokens: string[] = [];
+  let current = '';
+  let expectOperand = true;
+
+  for (let i = 0; i < expression.length; i++) {
+    const char = expression[i];
+    if ('+-*/'.includes(char)) {
+      const isUnaryMinus = char === '-' && expectOperand;
+      if (isUnaryMinus) {
+        current += char;
+        expectOperand = true;
+      } else {
+        if (expectOperand) {
+          // 2 consecutive operators or operator at the start
+          return [];
+        }
+        if (current !== '') {
+          tokens.push(current);
+          current = '';
+        }
+        tokens.push(char);
+        expectOperand = true;
+      }
+    } else {
+      current += char;
+      expectOperand = false;
+    }
+  }
+  if (current !== '') {
+    tokens.push(current);
+  }
+  return tokens;
+};
+
+// Matches a nested block of parenthesis
+const parenthesisRegex = new RegExp(/\([^)(]+\)/gm);
+
+// Match a positive decimal number
+const decimalRegex = new RegExp(/^\d+(.\d+)?$/gm);
+
+const validateBlock = (block: string, operands: string[] = [], variables: string[] = []) => {
+  // Remove parenthesis from the block
+  block = block.replaceAll("(", "").replaceAll(")", "");
+
+  // Split block on operators (Leave negative signs)
+  const tokens = splitByOperators(block);
+  if (tokens.length === 0) {
+    return false;
+  }
+  const components = tokens.filter(token => !'+-*/'.includes(token));
+
+  // Check if each bit is a valid operand
+  for (let i = 0; i < components.length; i++) {
+    // Remove negative sign
+    if (components[i].startsWith(MinusOperator)) {
+        components[i] = components[i].substring(1);
+    }
+    if (!operands.includes(components[i]) && !variables.includes(components[i]) && !components[i].match(decimalRegex)) {
+        return false;
+    }
+  }
+  return true;
+}
+
+export const validateOperation = (rawOperation: string, operands: string[] = [], variables: string[] = []) => {
+  // Remove spaces
+  let operation = rawOperation.replaceAll(" ", "");
+
+  // Check parenthesis
+  const parenthesis: number[] = [];
+
+  for (let i = 0; i < operation.length; i++) {
+    if (operation[i] == '(') {
+      parenthesis.push(i);
+    }
+    else if (operation[i] == ')') {
+      if (parenthesis.length > 0) {
+        if (i == parenthesis.pop()! + 1) {
+          return false;
+        }
+      }
+      else {
+        return false;
+      }
+    }
+  }
+  if (parenthesis.length > 0) {
+    return false;
+  }
+
+  // Check each block between parenthesis
+  let match = operation.match(parenthesisRegex);
+
+  while (match?.[0]) {
+    if (!validateBlock(match[0], operands, variables)) {
+      return false;
+    }
+    operation = operation.replace(match[0], "1");
+    match = operation.match(parenthesisRegex);
+  }
+  return validateBlock(operation, operands, variables);
+}

package/utils/picker.ts

@@ -0,0 +1,40 @@
+export enum TimePrecision {
+  Hours = 1,
+  Days = 2,
+  Months = 3
+}
+
+/**
+ *  Compute ticks for a time range based on the specified precision.
+ */
+export const computeTicks = ({ start, end, tickCount, precision }: { start: number, end: number, tickCount: number, precision: TimePrecision }): number[] => {
+  const ticks: number[] = [];
+  const range = end - start;
+
+  if (precision === TimePrecision.Hours) {
+    // Tick toutes les X heures, aligné sur l'heure pleine
+    const step = Math.ceil(range / tickCount / 3600000) * 3600000;
+    const alignedStart = Math.ceil(start / 3600000) * 3600000;
+    for (let i = 0; i < tickCount; i++) {
+      const tick = alignedStart + i * step;
+      if (tick < end) { ticks.push(tick); }
+    }
+  } else if (precision === TimePrecision.Days) {
+    // Tick tous les X jours, aligné sur minuit
+    const step = Math.ceil(range / tickCount / 86400000) * 86400000;
+    const date = new Date(start);
+    date.setHours(0, 0, 0, 0);
+    const alignedStart = date.getTime() + (date.getTime() < start ? step : 0);
+    for (let i = 0; i < tickCount; i++) {
+      const tick = alignedStart + i * step;
+      if (tick < end) { ticks.push(tick); }
+    }
+  } else {
+    // Tick tous les X mois (approximation linéaire)
+    const interval = range / tickCount;
+    for (let i = 0; i < tickCount; i++) {
+      ticks.push(start + i * interval);
+    }
+  }
+  return ticks;
+}

package/utils/sort.ts

@@ -23,7 +23,7 @@ export const alphanumericSort = (a: any, b: any) => {
   if (b == null) {
     return 1;
   }
-  a = asString(a);
-  b = asString(b);
+  a = asString(a).trim();
+  b = asString(b).trim();
   return a.localeCompare(b, undefined, { numeric: true });
 };

package/utils/time.ts

@@ -5,13 +5,13 @@ import { TimeUnit } from "@dative-gpi/foundation-shared-domain/enums"
 const { $tr } = useTranslationsProvider();
 
 export const timeSteps = [
-  { id: TimeUnit.Second,      label: $tr("ui.time-step.second.singular", "Second"), plural: $tr("ui.time-step.second.plural", "Seconds") },
-  { id: TimeUnit.Minute,      label: $tr("ui.time-step.minute.singular", "Minute"), plural: $tr("ui.time-step.minute.plural", "Minutes") },
-  { id: TimeUnit.Hour,        label: $tr("ui.time-step.hour.singular", "Hour"),     plural: $tr("ui.time-step.hour.plural", "Hours") },
-  { id: TimeUnit.Day,         label: $tr("ui.time-step.day.singular", "Day"),       plural: $tr("ui.time-step.day.plural", "Days") },
-  { id: TimeUnit.Week,        label: $tr("ui.time-step.week.singular", "Week"),     plural: $tr("ui.time-step.week.plural", "Weeks") },
-  { id: TimeUnit.Month,       label: $tr("ui.time-step.month.singular", "Month"),   plural: $tr("ui.time-step.month.plural", "Months") },
-  { id: TimeUnit.Year,        label: $tr("ui.time-step.year.singular", "Year"),     plural: $tr("ui.time-step.year.plural", "Years") },
+  { id: TimeUnit.Second, get label() { return $tr("ui.common.second", "Second") }, get plural() { return $tr("ui.common.seconds", "Seconds") } },
+  { id: TimeUnit.Minute, get label() { return $tr("ui.common.minute", "Minute") }, get plural() { return $tr("ui.common.minutes", "Minutes") } },
+  { id: TimeUnit.Hour,   get label() { return $tr("ui.common.hour", "Hour") },     get plural() { return $tr("ui.common.hours", "Hours") } },
+  { id: TimeUnit.Day,    get label() { return $tr("ui.common.day", "Day") },       get plural() { return $tr("ui.common.days", "Days") } },
+  { id: TimeUnit.Week,   get label() { return $tr("ui.common.week", "Week") },     get plural() { return $tr("ui.common.weeks", "Weeks") } },
+  { id: TimeUnit.Month,  get label() { return $tr("ui.common.month", "Month") },   get plural() { return $tr("ui.common.months", "Months") } },
+  { id: TimeUnit.Year,   get label() { return $tr("ui.common.year", "Year") },     get plural() { return $tr("ui.common.years", "Years") } },
 ];
 
 export const timeStepToString = (value: { value: number, unit: TimeUnit } | null): string => {
@@ -28,12 +28,12 @@ export const timeStepToString = (value: { value: number, unit: TimeUnit } | null
 };
 
 // TODO : remove everything below this line
-export const timeScale: any[] = [
-  { id: 1,      label: $tr("ui.time-field.second.singular", "Second"), plural: $tr("ui.time-field.second.plural", "Seconds") },
-  { id: 60,     label: $tr("ui.time-field.minute.singular", "Minute"), plural: $tr("ui.time-field.minute.plural", "Minutes") },
-  { id: 3600,   label: $tr("ui.time-field.hour.singular", "Hour"),     plural: $tr("ui.time-field.hour.plural", "Hours") },
-  { id: 86400,  label: $tr("ui.time-field.day.singular", "Day"),       plural: $tr("ui.time-field.day.plural", "Days") },
-  { id: 604800, label: $tr("ui.time-field.week.singular", "Week"),     plural: $tr("ui.time-field.week.plural", "Weeks") },
+export const timeScale = [
+  { id: 1,      get label() { return $tr("ui.common.second", "Second") }, get plural() { return $tr("ui.common.seconds", "Seconds") } },
+  { id: 60,     get label() { return $tr("ui.common.minute", "Minute") }, get plural() { return $tr("ui.common.minutes", "Minutes") } },
+  { id: 3600,   get label() { return $tr("ui.common.hour", "Hour") },     get plural() { return $tr("ui.common.hours", "Hours") } },
+  { id: 86400,  get label() { return $tr("ui.common.day", "Day") },       get plural() { return $tr("ui.common.days", "Days") } },
+  { id: 604800, get label() { return $tr("ui.common.week", "Week") },     get plural() { return $tr("ui.common.weeks", "Weeks") } },
 ];
 
 export const getTimeScaleIndex = (value: number): number => {

package/components/fields/FSMagicConfigField.vue

@@ -1,163 +0,0 @@
-<template>
-  <FSRow
-    class="fs-magic-config-field"
-  >
-    <component
-      class="fs-magic-config-field-value"
-      :is="get($props.type)"
-      :label="$tr('ui.magic-config-field.value', 'Value')"
-      :editable="$props.editable"
-      :required="true"
-      :rules="rules"
-      :modelValue="valueToInput"
-      @update:modelValue="inputToValue"
-    />
-    <FSRow
-      gap="24px"
-    >
-      <FSTranslateField
-        :label="$tr('ui.magic-config-field.label', 'Label')"
-        :editable="$props.editable"
-        :modelValue="$props.labelDefault"
-        :translations="$props.translations"
-        @update:modelValue="$emit('update:labelDefault', $event)"
-        @update:translations="$emit('update:translations', $event)"
-      />
-      <FSRow
-        class="fs-magic-config-field-actions"
-        width="hug"
-        :wrap="false"
-      >
-        <FSButtonRemoveIcon
-          @click="$emit('click:remove')"
-        />
-        <FSButtonAddIcon
-          @click="$emit('click:add')"
-        />
-      </FSRow>
-    </FSRow>
-  </FSRow>
-</template>
-
-<script lang="ts">
-import { computed, defineComponent, type PropType } from "vue";
-
-import { DateRules, IconRules, NumberRules, TextRules, TimeRules, TimeStepRules } from "../../models";
-import { useMagicFieldProvider } from "../../composables";
-import { MagicFieldType } from "../../models/magicFields";
-
-import FSButtonRemoveIcon from "../buttons/FSButtonRemoveIcon.vue";
-import FSButtonAddIcon from "../buttons/FSButtonAddIcon.vue";
-import FSTranslateField from "./FSTranslateField.vue";
-import FSRow from "../FSRow.vue";
-
-export default defineComponent({
-  name: "FSMagicConfigField",
-  components: {
-    FSButtonRemoveIcon,
-    FSTranslateField,
-    FSButtonAddIcon,
-    FSRow
-  },
-  props: {
-    type: {
-      type: Number as PropType<MagicFieldType>,
-      required: false,
-      default: MagicFieldType.TextField
-    },
-    labelDefault: {
-      type: String as PropType<string | null>,
-      required: false,
-      default: null
-    },
-    modelValue: {
-      type: String as PropType<string | null>,
-      required: false,
-      default: null
-    },
-    translations: {
-      type: Array as PropType<{ languageCode: string; label: string }[]>,
-      required: false,
-      default: () => []
-    },
-    editable: {
-      type: Boolean,
-      required: false,
-      default: true
-    }
-  },
-  emits: ["click:remove", "click:add", "update:modelValue", "update:labelDefault", "update:translations"],
-  setup(props, { emit }) {
-    const { get } = useMagicFieldProvider();
-
-    const rules = computed((): Function[] => {
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-          return [NumberRules.required()];
-        case MagicFieldType.TextField:
-          return [TextRules.required()];
-        case MagicFieldType.DateTimeField:
-          return [DateRules.required()];
-        case MagicFieldType.IconField:
-          return [IconRules.required()];
-        case MagicFieldType.TimeField:
-          return [TimeRules.required()];
-        case MagicFieldType.TimeStepField:
-          return [TimeStepRules.required()];
-      }
-      return [];
-    });
-
-    const valueToInput = computed((): any => {
-      if (!props.modelValue) {
-        return null;
-      }
-
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-        case MagicFieldType.DateTimeField:
-        case MagicFieldType.TimeField:
-          if (isNaN(parseFloat(props.modelValue))) {
-            return null;
-          }
-          return parseFloat(props.modelValue);
-        case MagicFieldType.Switch: 
-          return props.modelValue === "true";
-        case MagicFieldType.TimeStepField:
-          return JSON.parse(props.modelValue);
-        default:
-          return props.modelValue;
-      }
-    });
-
-    const inputToValue = (value: any) => {
-      if (!value) {
-        emit("update:modelValue", null);
-      }
-
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-        case MagicFieldType.Switch: 
-        case MagicFieldType.DateTimeField:
-        case MagicFieldType.TimeField:
-          emit("update:modelValue", value.toString());
-          break;
-        case MagicFieldType.TimeStepField:
-          emit("update:modelValue", JSON.stringify(value));
-          break;
-        default:
-          emit("update:modelValue", value);
-          break;
-      }
-    };
-
-    return {
-      MagicFieldType,
-      valueToInput,
-      rules,
-      inputToValue,
-      get
-    };
-  },
-});
-</script>

package/components/fields/FSMagicField.vue

@@ -1,193 +0,0 @@
-<template>
-  <component
-    v-if="!$props.useOnlyAllowedValues"
-    :is="get($props.type)"
-    :modelValue="valueToInput"
-    @update:modelValue="inputToValue"
-    v-bind="$attrs"
-  />
-  <FSSelectField
-    v-else
-    itemValue="value"
-    :items="items"
-    :modelValue="$props.modelValue"
-    @update:modelValue="$emit('update:modelValue', $event)"
-    v-bind="$attrs"
-  >
-    <template
-      v-if="$props.type === MagicFieldType.IconField"
-      #selection="{ item }"
-    >
-      <FSRow
-        align="center-center"
-        :wrap="false"
-      >
-        <FSIcon
-          v-if="item.raw.value"
-        >
-          {{ item.raw.value }}
-        </FSIcon>
-        <FSSpan
-          v-if="item.raw.value !== item.raw.label"
-        >
-          {{ item.raw.label }}
-        </FSSpan>
-      </FSRow>
-    </template>
-    <template
-      v-if="$props.type === MagicFieldType.IconField"
-      #item-label="{ item }"
-    >
-      <FSRow
-        align="center-center"
-        :wrap="false"
-      >
-        <FSIcon
-          v-if="item.raw.value"
-        >
-          {{ item.raw.value }}
-        </FSIcon>
-        <FSSpan
-          v-if="item.raw.value !== item.raw.label"
-        >
-          {{ item.raw.label }}
-        </FSSpan>
-      </FSRow>
-    </template>
-  </FSSelectField>
-</template>
-
-<script lang="ts">
-import { computed, defineComponent, type PropType } from "vue";
-
-import { useTranslations as useTranslationsProvider } from "@dative-gpi/bones-ui/composables";
-
-import { useDateFormat } from "@dative-gpi/foundation-shared-services/composables";
-
-import { useMagicFieldProvider } from "../../composables";
-import { MagicFieldType } from "../../models/magicFields";
-import { getTimeBestString, timeStepToString } from "../../utils";
-
-import FSSelectField from "./FSSelectField.vue";
-import FSIcon from "../FSIcon.vue";
-import FSSpan from "../FSSpan.vue";
-import FSRow from "../FSRow.vue";
-
-export default defineComponent({
-  name: "FSMagicField",
-  components: {
-    FSSelectField,
-    FSIcon,
-    FSSpan,
-    FSRow
-  },
-  props: {
-    type: {
-      type: Number as PropType<MagicFieldType>,
-      required: false,
-      default: MagicFieldType.TextField
-    },
-    modelValue: {
-      type: String as PropType<string | null>,
-      required: false,
-      default: null
-    },
-    allowedValues: {
-      type: Array as PropType<{ value: string; label: string }[]>,
-      required: false,
-      default: () => []
-    },
-    useOnlyAllowedValues: {
-      type: Boolean,
-      required: false,
-      default: false
-    },
-  },
-  emits: ["update:modelValue"],
-  setup(props, { emit }) {
-    const { epochToShortTimeFormat } = useDateFormat();
-    const { $tr } = useTranslationsProvider();
-    const { get } = useMagicFieldProvider();
-
-    const items = computed(() => props.allowedValues.map((av) => ({
-      value: av.value,
-      label: av.label || asString(av.value),
-    })));
-
-    const valueToInput = computed((): any => {
-      if (props.modelValue == null) {
-        return null;
-      }
-
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-        case MagicFieldType.DateTimeField:
-        case MagicFieldType.TimeField:
-          if (isNaN(parseFloat(props.modelValue))) {
-            return null;
-          }
-          return parseFloat(props.modelValue);
-        case MagicFieldType.Switch: 
-          return props.modelValue === "true";
-        case MagicFieldType.TimeStepField:
-          return JSON.parse(props.modelValue);
-        default:
-          return props.modelValue;
-      }
-    });
-
-    const asString = (value: string): string | null => {
-      if (value == null) {
-        return "";
-      }
-      
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-          return value.toString();
-        case MagicFieldType.Switch:
-          if (value) {
-            return $tr("ui.magic-field.true", "True");
-          }
-          return $tr("ui.magic-field.false", "False");
-        case MagicFieldType.DateTimeField:
-          return epochToShortTimeFormat(parseFloat(value));
-        case MagicFieldType.TimeField:
-          return getTimeBestString(parseFloat(value));
-        case MagicFieldType.TimeStepField:
-          return timeStepToString(JSON.parse(value));
-        default:
-          return value;
-      }
-    }
-
-    const inputToValue = (value: any) => {
-      if (value == null) {
-        emit("update:modelValue", null);
-      }
-
-      switch (props.type) {
-        case MagicFieldType.NumberField:
-        case MagicFieldType.Switch: 
-        case MagicFieldType.DateTimeField:
-        case MagicFieldType.TimeField:
-          emit("update:modelValue", value.toString());
-          break;
-        case MagicFieldType.TimeStepField:
-          emit("update:modelValue", JSON.stringify(value));
-          break;
-        default:
-          emit("update:modelValue", value);
-          break;
-      }
-    };
-
-    return {
-      MagicFieldType,
-      valueToInput,
-      items,
-      inputToValue,
-      get
-    };
-  },
-});
-</script>