@socialgouv/modeles-social 4.76.0 → 4.78.0

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [4.78.0](https://github.com/SocialGouv/code-du-travail-numerique/compare/v4.77.1...v4.78.0) (2022-06-16)
+
+**Note:** Version bump only for package @socialgouv/modeles-social
+
+
+
+
+
+## [4.77.1](https://github.com/SocialGouv/code-du-travail-numerique/compare/v4.77.0...v4.77.1) (2022-05-18)
+
+**Note:** Version bump only for package @socialgouv/modeles-social
+
+
+
+
+
+# [4.77.0](https://github.com/SocialGouv/code-du-travail-numerique/compare/v4.76.0...v4.77.0) (2022-05-12)
+
+
+### Features
+
+* **simulator:** amélioration de la gestion du state ([#4383](https://github.com/SocialGouv/code-du-travail-numerique/issues/4383)) ([075ab8a](https://github.com/SocialGouv/code-du-travail-numerique/commit/075ab8abd6595d0bf4935c0185e6ac6b95501b4e)), closes [#4380](https://github.com/SocialGouv/code-du-travail-numerique/issues/4380) [#4382](https://github.com/SocialGouv/code-du-travail-numerique/issues/4382) [#4384](https://github.com/SocialGouv/code-du-travail-numerique/issues/4384)
+
+
+
+
+
 # [4.76.0](https://github.com/SocialGouv/code-du-travail-numerique/compare/v4.75.4...v4.76.0) (2022-04-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socialgouv/modeles-social",
-  "version": "4.76.0",
+  "version": "4.78.0",
   "description": "Les règles publicodes des simulateurs de code du travail numérique",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -40,5 +40,5 @@
       "yarn lint --fix"
     ]
   },
-  "gitHead": "9c3eb4ab865511efef7e232c19bc14f636ff6bc5"
+  "gitHead": "40fac67eea470def4c762cbf5d5eb542f4b77889"
 }

package/src/index.ts

@@ -1,2 +1,3 @@
 export { default as modeles } from "./modeles/modeles.json";
+export * from "./publicodes";
 export * from "./utils";

package/src/internal/build.ts

@@ -33,6 +33,7 @@ function copyJSFile() {
     path.resolve(outDir, "index.d.ts")
   );
   fse.copySync(`${inDir}/utils`, `${outDir}/utils`);
+  fse.copySync(`${inDir}/publicodes`, `${outDir}/publicodes`);
 }
 
 function writeSupportedCCFile() {

package/src/publicodes/PreavisRetraitePublicodes.ts

@@ -0,0 +1,26 @@
+import type { EvaluatedNode } from "publicodes";
+
+import type { Publicodes } from "./Publicodes";
+import { PublicodesBase } from "./PublicodesBase";
+import type { PublicodesPreavisRetraiteResult } from "./types";
+import { PublicodesSimulator } from "./types";
+import { convertDaysIntoBetterUnit } from "./utils";
+
+class PreavisRetraitePublicodes
+  extends PublicodesBase<PublicodesPreavisRetraiteResult>
+  implements Publicodes<PublicodesPreavisRetraiteResult>
+{
+  constructor(rules: string) {
+    super(rules, PublicodesSimulator.PREAVIS_RETRAITE);
+  }
+
+  protected convertedResult(
+    evaluatedNode: EvaluatedNode
+  ): PublicodesPreavisRetraiteResult {
+    return convertDaysIntoBetterUnit(
+      evaluatedNode.nodeValue as unknown as string
+    );
+  }
+}
+
+export default PreavisRetraitePublicodes;

package/src/publicodes/Publicodes.ts

@@ -0,0 +1,10 @@
+import type { Notification, References } from "../utils";
+import type { PublicodesData } from "./types";
+
+export interface Publicodes<TResult> {
+  readonly data: PublicodesData<TResult>;
+  execute: (rule: string) => TResult;
+  setSituation: (args: Record<string, string>) => PublicodesData<TResult>;
+  getNotifications: () => Notification[];
+  getReferences: () => References[];
+}

package/src/publicodes/PublicodesBase.ts

@@ -0,0 +1,131 @@
+import type { EvaluatedNode } from "publicodes";
+import Engine from "publicodes";
+
+import type { Notification, References } from "../utils";
+import { getNotifications, getReferences } from "../utils";
+import type { Publicodes } from "./Publicodes";
+import type { MissingArgs, PublicodesData, SituationElement } from "./types";
+
+export abstract class PublicodesBase<TResult> implements Publicodes<TResult> {
+  engine: Engine;
+
+  targetRule: string;
+
+  data: PublicodesData<TResult> = {
+    missingArgs: [],
+    result: {} as TResult,
+    situation: [],
+  };
+
+  protected constructor(rules: string, targetRule: string) {
+    this.engine = new Engine(rules);
+    this.targetRule = targetRule;
+  }
+
+  execute(rule: string): TResult {
+    const result = this.handleExecute(this.data.situation, rule);
+    return this.convertedResult(result);
+  }
+
+  setSituation(args: Record<string, string>): PublicodesData<TResult> {
+    const { missingArgs, result, situation } = this.updateSituation(
+      this.data.situation,
+      args
+    );
+    this.data = {
+      missingArgs,
+      result: this.convertedResult(result),
+      situation,
+    };
+    return this.data;
+  }
+
+  getNotifications(): Notification[] {
+    return getNotifications(this.engine);
+  }
+
+  getReferences(): References[] {
+    return getReferences(this.engine);
+  }
+
+  private buildSituation(map: SituationElement[]): Record<string, string> {
+    const situation: Record<string, string> = {};
+    map.forEach((arg) => {
+      situation[arg.rawNode.nom] = arg.value;
+    });
+    return situation;
+  }
+
+  private buildMissingArgs(
+    engine: Engine,
+    missingArgs: Record<string, number>
+  ): MissingArgs[] {
+    return Object.entries(missingArgs)
+      .map(([key, value]) => {
+        const detail = engine.getRule(key);
+        return {
+          indice: value,
+          name: key.replace(/ \. /g, " - "),
+          rawNode: detail.rawNode,
+        };
+      })
+      .sort((a, b) => b.indice - a.indice);
+  }
+
+  private handleExecute(
+    situation: SituationElement[],
+    rule: string
+  ): EvaluatedNode {
+    this.engine.setSituation(this.buildSituation(situation));
+    return this.engine.evaluate(rule);
+  }
+
+  private updateSituation(
+    situation: SituationElement[],
+    args: Record<string, string>
+  ): {
+    missingArgs: MissingArgs[];
+    result: EvaluatedNode;
+    situation: SituationElement[];
+  } {
+    // Situation is an array to keep the order of the answers
+    const currentSituation = situation;
+    const newSituation: SituationElement[] = [];
+
+    // Update the current situation with new values
+    currentSituation.forEach((element) => {
+      // Keep the data only if always here in the form
+      if (args[element.name]) {
+        newSituation.push({
+          name: element.name,
+          rawNode: element.rawNode,
+          value: args[element.name],
+        });
+      }
+    });
+
+    // Add the new entries from the form
+    Object.entries(args).forEach(([key, value]) => {
+      if (!newSituation.find((element) => element.name === key)) {
+        const publiKey = key.replace(/ - /g, " . ");
+        const detail = this.engine.getRule(publiKey);
+        newSituation.push({
+          name: key,
+          rawNode: detail.rawNode,
+          value: value,
+        });
+      }
+    });
+
+    this.engine.setSituation(this.buildSituation(newSituation));
+    const result = this.engine.evaluate(this.targetRule);
+
+    return {
+      missingArgs: this.buildMissingArgs(this.engine, result.missingVariables),
+      result,
+      situation: newSituation,
+    };
+  }
+
+  protected abstract convertedResult(evaluatedNode: EvaluatedNode): TResult;
+}

package/src/publicodes/__tests__/PreavisRetraitePublicodes.test.ts

@@ -0,0 +1,115 @@
+import { mergeModels } from "../../internal/merger";
+import PreavisRetraitePublicodes from "../PreavisRetraitePublicodes";
+
+const partialSituation = [
+  {
+    name: "contrat salarié . convention collective",
+    rawNode: {
+      nom: "contrat salarié . convention collective",
+      "par défaut": "''",
+      question: "Quelle est votre convention collective ?",
+      titre: "Convention collective",
+    },
+    value: "''",
+  },
+  {
+    name: "contrat salarié . mise à la retraite",
+    rawNode: {
+      cdtn: {
+        type: "liste",
+        valeurs: {
+          "Départ à la retraite": "non",
+          "Mise à la retraite": "oui",
+        },
+      },
+      nom: "contrat salarié . mise à la retraite",
+      question:
+        "L’employeur a-t-il décidé de lui-même de mettre à la retraite le salarié par une décision adressée à celui-ci ?",
+      titre: "Origine du départ à la retraite",
+    },
+    value: "oui",
+  },
+  {
+    name: "contrat salarié . travailleur handicapé",
+    rawNode: {
+      cdtn: { type: "oui-non" },
+      nom: "contrat salarié . travailleur handicapé",
+      question:
+        "Le salarié concerné est-il reconnu en tant que travailleur handicapé ?",
+      titre: "Travailleur handicapé",
+    },
+    value: "non",
+  },
+  {
+    name: "préavis de retraite",
+    rawNode: {
+      nom: "préavis de retraite",
+      "rend non applicable": "contrat salarié . indemnité de licenciement",
+      valeur: "non",
+    },
+    value: "oui",
+  },
+];
+
+const ancienneteSituation = {
+  name: "contrat salarié . ancienneté",
+  rawNode: {
+    cdtn: {
+      type: "entier",
+    },
+    nom: "contrat salarié . ancienneté",
+    question: "Quel est votre ancienneté en mois ?",
+    titre: "Ancienneté du salarié",
+    unité: "mois",
+  },
+  value: "24",
+};
+
+describe("PreavisRetraitePublicodes::class", () => {
+  const publicodes = new PreavisRetraitePublicodes(mergeModels());
+
+  it("doit mettre à jour la situation", () => {
+    publicodes.setSituation({
+      "contrat salarié . convention collective": "''",
+      "contrat salarié . mise à la retraite": "oui",
+      "contrat salarié . travailleur handicapé": "non",
+      "préavis de retraite": "oui",
+    });
+    expect(publicodes.data.situation).toEqual(partialSituation);
+  });
+
+  it("doit retourner l'information manquante sur l'ancienneté", () => {
+    expect(publicodes.data.missingArgs).toHaveLength(1);
+    expect(publicodes.data.missingArgs[0].name).toBe(
+      "contrat salarié - ancienneté"
+    );
+  });
+  it("ne doit pas retourner de résultat", () => {
+    expect(publicodes.data.result.value).toBe(0);
+  });
+
+  it("doit mettre à jour la situation avec l'ancienneté", () => {
+    publicodes.setSituation({
+      "contrat salarié . ancienneté": "24",
+      "contrat salarié . convention collective": "''",
+      "contrat salarié . mise à la retraite": "oui",
+      "contrat salarié . travailleur handicapé": "non",
+      "préavis de retraite": "oui",
+    });
+    expect(publicodes.data.situation).toEqual(
+      partialSituation.concat(ancienneteSituation)
+    );
+  });
+
+  it("ne doit retourner aucunes informations manquantes", () => {
+    expect(publicodes.data.missingArgs).toHaveLength(0);
+  });
+
+  it("doit retourner le résultat", () => {
+    expect(publicodes.data.result).toEqual({
+      unit: "mois",
+      value: 2,
+      valueInDays: 60.833333333333336,
+    });
+  });
+});

package/src/publicodes/index.ts

@@ -0,0 +1,3 @@
+export { default as PreavisRetraitePublicodes } from "./PreavisRetraitePublicodes";
+export * from "./Publicodes";
+export * from "./types";

package/src/publicodes/types.ts

@@ -0,0 +1,87 @@
+import type Engine from "publicodes";
+import type { Evaluation, Unit } from "publicodes";
+import type { Rule as PubliRule } from "publicodes/dist/types/rule";
+
+export type OldReference = {
+  ref: string;
+  refUrl: string;
+};
+
+export interface MissingArgs {
+  name: string;
+  indice: number;
+  rawNode: Rule;
+}
+
+export enum RuleType {
+  Liste = "liste",
+  OuiNon = "oui-non",
+  SalaireMensuel = "salaire-mensuel",
+}
+
+export interface RuleListe {
+  type: RuleType;
+  valeurs: Record<string, string>;
+}
+
+export type RuleCdtn = RuleListe;
+
+export interface Rule extends PubliRule {
+  cdtn?: RuleCdtn;
+}
+
+export interface SituationElement {
+  name: string;
+  rawNode: Rule;
+  value: string;
+}
+
+export type PublicodesState = {
+  engine: Engine;
+  targetRule: string;
+};
+
+export type PublicodesData<TResult> = {
+  situation: SituationElement[];
+  missingArgs: MissingArgs[];
+  result: TResult;
+};
+
+export type PublicodesProviderRule = {
+  children: React.ReactNode;
+  rules: any;
+  simulator: PublicodesSimulator;
+};
+
+export enum PublicodesUnit {
+  DAY = "jour",
+  MONTH = "mois",
+  YEAR = "an",
+  EUROS = "€",
+  K_EUROS = "k/€",
+}
+
+export enum PublicodesSimulator {
+  INDEMNITE_LICENCIEMENT = "contrat salarié . indemnité de licenciement",
+  PREAVIS_RETRAITE = "contrat salarié . préavis de retraite en jours",
+}
+
+export enum PublicodesConvertedUnit {
+  DAY = "jour",
+  MONTH = "mois",
+  YEAR = "an",
+  DAYS = "jours",
+  WEEK = "semaine",
+  WEEKS = "semaines",
+}
+
+export type PublicodesPreavisRetraiteResult = {
+  value: number;
+  unit: PublicodesConvertedUnit;
+  valueInDays: number;
+};
+
+export type PublicodesIndemniteLicenciementResult = {
+  value: Evaluation;
+  unit?: Unit;
+};

package/src/publicodes/utils/__tests__/preavis-retraite.test.ts

@@ -0,0 +1,35 @@
+import { PublicodesConvertedUnit } from "../../types";
+import { convertDaysIntoBetterUnit } from "..";
+
+describe("Testing the transformation of the unit from publicodes (in days) into a better unit (weeks or months)", () => {
+  it.each`
+    input      | expectedUnit                     | expectedValue
+    ${1}       | ${PublicodesConvertedUnit.DAY}   | ${1}
+    ${"1"}     | ${PublicodesConvertedUnit.DAY}   | ${1}
+    ${2}       | ${PublicodesConvertedUnit.DAYS}  | ${2}
+    ${"2"}     | ${PublicodesConvertedUnit.DAYS}  | ${2}
+    ${10}      | ${PublicodesConvertedUnit.DAYS}  | ${10}
+    ${"12"}    | ${PublicodesConvertedUnit.DAYS}  | ${12}
+    ${7}       | ${PublicodesConvertedUnit.WEEK}  | ${1}
+    ${"14"}    | ${PublicodesConvertedUnit.WEEKS} | ${2}
+    ${21}      | ${PublicodesConvertedUnit.WEEKS} | ${3}
+    ${"30.42"} | ${PublicodesConvertedUnit.MONTH} | ${1}
+    ${60.83}   | ${PublicodesConvertedUnit.MONTH} | ${2}
+    ${182.5}   | ${PublicodesConvertedUnit.MONTH} | ${6}
+    ${365}     | ${PublicodesConvertedUnit.MONTH} | ${12}
+    ${"730"}   | ${PublicodesConvertedUnit.MONTH} | ${24}
+    ${28}      | ${PublicodesConvertedUnit.WEEKS} | ${4}
+    ${30}      | ${PublicodesConvertedUnit.DAYS}  | ${30}
+    ${35}      | ${PublicodesConvertedUnit.WEEKS} | ${5}
+    ${45}      | ${PublicodesConvertedUnit.DAYS}  | ${45}
+  `(
+    "should return $expectedValue $expectedUnit for $input day(s)",
+    ({ input, expectedUnit, expectedValue }) => {
+      expect(convertDaysIntoBetterUnit(input)).toEqual({
+        unit: expectedUnit,
+        value: expectedValue,
+        valueInDays: parseFloat(input),
+      });
+    }
+  );
+});

package/src/publicodes/utils/common.ts

@@ -0,0 +1,7 @@
+export function isFloat(n: number): boolean {
+  return Number(n) === n && n % 1 !== 0;
+}
+
+export function formatNumber(toBeFormmatted: number): string {
+  return isNaN(toBeFormmatted) ? "0" : toBeFormmatted.toString();
+}

package/src/publicodes/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./common";
+export * from "./preavis-retraite";

package/src/publicodes/utils/preavis-retraite.ts

@@ -0,0 +1,38 @@
+import type { PublicodesPreavisRetraiteResult } from "../types";
+import { PublicodesConvertedUnit } from "../types";
+import { isFloat } from ".";
+
+export const convertDaysIntoBetterUnit = (
+  days: number | string
+): PublicodesPreavisRetraiteResult => {
+  const parsedDay = typeof days === "string" ? parseFloat(days) : days;
+  const isDay = parsedDay === 1;
+  const isConvertibleIntoWeek = parsedDay % 7 === 0;
+  if (isConvertibleIntoWeek) {
+    const parsedWeek = parsedDay / 7;
+    const isWeek = parsedWeek === 1;
+    return {
+      unit: isWeek
+        ? PublicodesConvertedUnit.WEEK
+        : PublicodesConvertedUnit.WEEKS,
+      value: parsedWeek,
+      valueInDays: parsedDay,
+    };
+  }
+  // Hack: publicodes round value when convert months to days.
+  // So we loose accuracy, we just look if the value is a float or modulo 365 == 0
+  const isConvertibleIntoMonth = isFloat(parsedDay) || parsedDay % 365 === 0;
+  if (isConvertibleIntoMonth) {
+    const parsedMonth = Math.round(parsedDay / (365 / 12));
+    return {
+      unit: PublicodesConvertedUnit.MONTH,
+      value: parsedMonth,
+      valueInDays: parsedDay,
+    };
+  }
+  return {
+    unit: isDay ? PublicodesConvertedUnit.DAY : PublicodesConvertedUnit.DAYS,
+    value: parsedDay,
+    valueInDays: parsedDay,
+  };
+};