math-exercises 2.2.14 → 2.2.16

package/lib/exercises/pc/mecanicalWaves/elongationReading.js

@@ -19,9 +19,10 @@ const getElongationReadingQuestion = () => {
         `f(x) = If(x>=0, ${amplitude}*cos(x* (2*PI)/${period}))`,
         `SetColor(f, "${(0, colors_1.randomColor)()}")`,
     ];
-    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
-        isGridSimple: true,
-        axisLabels: ["$\\tiny \\text{Temps (s)}$", "$\\tiny \\text{y (cm)}$"],
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        xAxis: { label: "$\\tiny \\text{Temps (s)}$" },
+        yAxis: { label: "$\\tiny \\text{y (cm)}$" },
     });
     const frac = new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode((2).toTree(), piNode_1.PiNode), period.toTree()).simplify();
     const node = new multiplyNode_1.MultiplyNode(amplitude.toTree(), new cosNode_1.CosNode(new multiplyNode_1.MultiplyNode(frac, new variableNode_1.VariableNode("t"))));
@@ -31,9 +32,9 @@ const getElongationReadingQuestion = () => {
         keys: ["y", "t", "pi", "cos", "equal"],
         answerFormat: "tex",
         identifiers: { amplitude, period },
-        commands: ggb.commands,
-        options: ggb.getOptions(),
-        coords: [-1, 20, -10, 10],
+        ggbOptions: ggb.getOptions({
+            coords: [-1, 20, -10, 10],
+        }),
     };
     return question;
 };

package/lib/exercises/pc/mole/concentrationReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concentrationReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mole/concentrationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AA0CtB,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"concentrationReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mole/concentrationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AA4CtB,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/pc/mole/concentrationReading.js

@@ -14,10 +14,12 @@ const getConcentrationReadingQuestion = () => {
         `SetFixed(L, true)`,
         `SetColor(L, "${(0, colors_1.randomColor)()}")`,
     ];
-    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
         isGridSimple: false,
-        isAxesRatioFixed: false,
-        axisLabels: ["$\\tiny C (\\text{mol}\\cdot \\text{L}^{-1})$", "$\\tiny A$"],
+        lockedAxesRatio: false,
+        xAxis: { label: "$\\tiny C (\\text{mol}\\cdot \\text{L}^{-1})$" },
+        yAxis: { label: "$\\tiny A$" },
     });
     const question = {
         answer: concentration + "",
@@ -25,9 +27,9 @@ const getConcentrationReadingQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: {},
-        commands: ggb.commands,
-        options: ggb.getOptions(),
-        coords: [-1, concentration + 2, -1, absorbtion + 2],
+        ggbOptions: ggb.getOptions({
+            coords: [-1, concentration + 2, -1, absorbtion + 2],
+        }),
     };
     return question;
 };

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"characteristicsOfVelocityVector.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/characteristicsOfVelocityVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"characteristicsOfVelocityVector.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/characteristicsOfVelocityVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAoFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.js

@@ -13,8 +13,7 @@ const getCharacteristicsOfVelocityVectorQuestion = () => {
         answer: exo.answer.frenchify(),
         instruction: exo.instruction,
         keys: [],
-        commands: exo.ggb.commands,
-        coords: exo.ggbCoords,
+        ggbOptions: exo.ggb.getOptions({ coords: exo.ggbCoords }),
         answerFormat: "tex",
         identifiers: { norm: exo.answer },
     };
@@ -43,7 +42,7 @@ const generateExercise = () => {
     const answer = ggb.speedVector.norm;
     return {
         instruction,
-        ggb: new geogebraConstructor_1.GeogebraConstructor(ggb.commands, { isAxesRatioFixed: true }),
+        ggb: new geogebraConstructor_1.GeogebraConstructor({ commands: ggb.commands }),
         ggbCoords: ggb.coords,
         answer,
     };

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmFtB,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAoFtB,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/pc/motion/typeOfAcceleration.js

@@ -11,9 +11,9 @@ const getTypeOfAccelerationQuestion = () => {
     const question = {
         answer: exo.answer,
         instruction: exo.instruction,
-        commands: exo.ggb.object.commands,
-        options: exo.ggb.object.getOptions(),
-        coords: exo.ggb.coords,
+        ggbOptions: exo.ggb.object.getOptions({
+            coords: exo.ggb.coords,
+        }),
         keys: [],
         answerFormat: "raw",
         identifiers: {},
@@ -51,7 +51,8 @@ const generateExo = () => {
 const generateGgb = (typeOfAcceleration) => {
     const points = getPoints(typeOfAcceleration);
     return {
-        object: new geogebraConstructor_1.GeogebraConstructor(points.points, {
+        object: new geogebraConstructor_1.GeogebraConstructor({
+            commands: points.points,
             hideAxes: true,
             hideGrid: true,
         }),

package/lib/exercises/pc/motion/typeOfMovement.js

@@ -13,9 +13,9 @@ const getTypeOfMovementQuestion = () => {
     const question = {
         answer: exo.answer,
         instruction: exo.instruction,
-        commands: ggb.commands,
-        coords: exo.coords,
-        options: ggb.getOptions(),
+        ggbOptions: ggb.getOptions({
+            coords: exo.coords,
+        }),
         keys: [],
         answerFormat: "raw",
         identifiers: {},
@@ -76,7 +76,7 @@ const getGgb = (movementType) => {
             break;
     }
     return {
-        ggb: new geogebraConstructor_1.GeogebraConstructor(commands, {}),
+        ggb: new geogebraConstructor_1.GeogebraConstructor({ commands }),
         coords,
     };
 };

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkHtB,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAavE,CAAC"}
+{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmHtB,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAavE,CAAC"}

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -23,9 +23,9 @@ const getRecognizeRefractionOrReflectionAnglesQuestion = () => {
         answer: exo.isAsking,
         instruction: `Un rayon arrive sur la surface de séparation entre deux milieux. Comment appelle-t-on l'angle représenté ci-dessous ?`,
         keys: [],
-        commands: exo.ggb.commands,
-        coords: exo.coords,
-        options: exo.ggb.getOptions(),
+        ggbOptions: exo.ggb.getOptions({
+            coords: exo.coords,
+        }),
         answerFormat: "raw",
         identifiers: {},
     };
@@ -76,7 +76,8 @@ const generateExercise = () => {
         `SetColor(Second,"#0a6a01")`,
         `SetColor(Ang,"#6a0101")`,
     ];
-    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
         hideGrid: true,
         hideAxes: true,
     });

package/lib/exercises/pc/sound/findPeriodFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findPeriodFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAkEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"findPeriodFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAoEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/pc/sound/findPeriodFromGraph.js

@@ -37,8 +37,10 @@ const getFindPeriodFromGraphQuestion = () => {
     for (let i = 1; i < 10; i++) {
         commands.push(`S_{${i}} = Translate(S, (${i * period}, 0))`, `SetFixed(S_{${i}}, true)`, `SetColor(S_{${i}}, "${color}")`);
     }
-    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
-        axisLabels: ["$\\tiny Temps (ms)$", "$\\tiny Tension (V)$"],
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        xAxis: { label: "$\\tiny Temps (ms)$" },
+        yAxis: { label: "$\\tiny Tension (V)$" },
         isGridSimple: true,
     });
     const question = {
@@ -47,9 +49,9 @@ const getFindPeriodFromGraphQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { period, splinePoints },
-        commands: ggb.commands,
-        options: ggb.getOptions(),
-        coords: [0, 20, -8, 8],
+        ggbOptions: ggb.getOptions({
+            coords: [0, 20, -8, 8],
+        }),
     };
     return question;
 };

package/lib/exercises/pc/sound/findPeriodOrFrequencyFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findPeriodOrFrequencyFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodOrFrequencyFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAqFF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}
+{"version":3,"file":"findPeriodOrFrequencyFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodOrFrequencyFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAsFF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}

package/lib/exercises/pc/sound/findPeriodOrFrequencyFromGraph.js

@@ -38,9 +38,10 @@ const getFindPeriodOrFrequencyFromGraphQuestion = () => {
     for (let i = 1; i < 10; i++) {
         commands.push(`S_{${i}} = Translate(S, (${i * period}, 0))`, `SetFixed(S_{${i}}, true)`, `SetColor(S_{${i}}, "${color}")`);
     }
-    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
-        axisLabels: ["$\\tiny Temps (ms)$", "$\\tiny Tension (V)$"],
-        isGridSimple: true,
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        xAxis: { label: "$\\tiny Temps (ms)$" },
+        yAxis: { label: "$\\tiny Tension (V)$" },
     });
     const isAsking = (0, coinFlip_1.coinFlip)() ? `période` : `fréquence`;
     const frequency = (1 / period) * 1000;
@@ -54,9 +55,9 @@ const getFindPeriodOrFrequencyFromGraphQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { period, frequency, splinePoints },
-        commands: ggb.commands,
-        options: ggb.getOptions(),
-        coords: [0, 20, -8, 8],
+        ggbOptions: ggb.getOptions({
+            coords: [0, 20, -8, 8],
+        }),
     };
     return question;
 };

package/lib/exercises/utils/getDistinctQuestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,KACX,SAAS,GAAG,CAAC,EAmBf,CAAC"}
+{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,KACX,SAAS,GAAG,CAAC,EAoBf,CAAC"}

package/lib/exercises/utils/getDistinctQuestions.js

@@ -30,7 +30,8 @@ const getDistinctQuestions = (generator, nb, max) => {
             question = generator();
         } while (res.some((q) => q.instruction === question.instruction &&
             q.answer === question.answer &&
-            (!q.commands || equalTab(q.commands, question.commands))));
+            (!q.ggbOptions?.commands ||
+                equalTab(q.ggbOptions?.commands, question.ggbOptions?.commands))));
         res.push(question);
     }
     return res;

package/lib/geogebra/geogebraConstructor.d.ts

@@ -1,14 +1,4 @@
-type GeogebraOptions = {
-    isAxesRatioFixed?: boolean;
-    gridDistance?: [number, number] | false;
-    hideAxes?: boolean;
-    hideGrid?: boolean;
-    isGridBold?: boolean;
-    isGridSimple?: boolean;
-    isXAxesNatural?: boolean;
-    axisLabels?: string[];
-    is3D?: boolean;
-};
+import { GeogebraAxisOptions, GeogebraOptions } from "../exercises/exercise";
 type GetAdaptedCoords = {
     xMin: number;
     xMax: number;
@@ -18,20 +8,25 @@ type GetAdaptedCoords = {
     zMax?: number;
     forceShowAxes?: boolean;
 };
+type GetOptionsProps = {
+    coords: number[];
+};
 export declare class GeogebraConstructor {
-    commands: string[];
-    gridDistance: [number, number] | false;
-    hideGrid: boolean;
-    hideAxes: boolean;
-    isGridSimple: boolean;
-    isGridBold: boolean;
-    is3D: boolean;
-    isAxesRatioFixed: boolean;
-    isXAxesNatural: boolean;
-    axisLabels?: string[];
-    constructor(commands: string[], options: GeogebraOptions | undefined);
+    customToolBar?: string;
+    forbidShiftDragZoom?: boolean;
+    commands?: string[];
+    is3D?: boolean;
+    gridDistance?: [number, number] | false;
+    hideGrid?: boolean;
+    hideAxes?: boolean;
+    isGridSimple?: boolean;
+    isGridBold?: boolean;
+    lockedAxesRatio?: number | false;
+    xAxis?: GeogebraAxisOptions;
+    yAxis?: GeogebraAxisOptions;
+    constructor(options: Omit<GeogebraOptions, "coords">);
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];
-    getOptions(): GeogebraOptions;
+    getOptions({ coords }: GetOptionsProps): GeogebraOptions;
 }
 export {};
 //# sourceMappingURL=geogebraConstructor.d.ts.map

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;gBACV,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAapE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,IAAI,eAAe;CAa9B"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAGhF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAepD,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeogebraConstructor = void 0;
+const toolBarConstructor_1 = require("../exercises/utils/geogebra/toolBarConstructor");
 class GeogebraConstructor {
-    constructor(commands, options) {
-        this.commands = commands;
-        this.isAxesRatioFixed = options?.isAxesRatioFixed ?? true;
+    constructor(options) {
+        this.customToolBar = options?.customToolBar ?? (0, toolBarConstructor_1.toolBarConstructor)({});
+        this.forbidShiftDragZoom = options?.forbidShiftDragZoom;
+        this.commands = options.commands;
+        this.is3D = options?.is3D;
         this.gridDistance = options?.gridDistance ?? [1, 1];
-        this.hideGrid = options?.hideGrid ?? false;
-        this.hideAxes = options?.hideAxes ?? false;
-        this.isGridBold = options?.isGridBold ?? false;
-        this.isGridSimple = options?.isGridSimple ?? false;
-        this.isXAxesNatural = options?.isXAxesNatural ?? false;
-        this.axisLabels = options?.axisLabels ?? undefined;
-        this.is3D = options?.is3D ?? false;
+        this.hideGrid = options?.hideGrid;
+        this.hideAxes = options?.hideAxes;
+        this.isGridBold = options?.isGridBold;
+        this.isGridSimple = options?.isGridSimple ?? true;
+        this.lockedAxesRatio = options?.lockedAxesRatio ?? 1;
+        this.xAxis = options?.xAxis;
+        this.yAxis = options?.yAxis;
     }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
         const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
@@ -54,17 +57,21 @@ class GeogebraConstructor {
             return coords;
         }
     }
-    getOptions() {
+    getOptions({ coords }) {
         return {
+            customToolBar: this.customToolBar,
+            forbidShiftDragZoom: this.forbidShiftDragZoom,
+            commands: this.commands,
+            coords: coords,
+            is3D: this.is3D,
+            gridDistance: this.gridDistance,
             hideAxes: this.hideAxes,
             hideGrid: this.hideGrid,
             isGridBold: this.isGridBold,
             isGridSimple: this.isGridSimple,
-            gridDistance: this.gridDistance,
-            isAxesRatioFixed: this.isAxesRatioFixed,
-            isXAxesNatural: this.isXAxesNatural,
-            axisLabels: this.axisLabels,
-            is3D: this.is3D,
+            lockedAxesRatio: this.lockedAxesRatio,
+            xAxis: this.xAxis,
+            yAxis: this.yAxis,
         };
     }
 }

package/lib/index.d.ts

@@ -1,47 +1,4 @@
-import { AlgebraicNode } from "./tree/nodes/algebraicNode";
-declare global {
-    interface Number {
-        toTree: () => AlgebraicNode;
-        frenchify: () => string;
-        toScientific: (decimals?: number) => AlgebraicNode;
-    }
-    interface String {
-        toTree: () => AlgebraicNode;
-        unfrenchify: () => number;
-    }
-}
-/**
- * TODO
- * Décimal : permettre facilement -0.xxx
- * Tree shaking export
- *
- * VEA:
- *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
- *      ->> faire le meme delire que pour les power mais pour les opposite ?
- *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
- *  -> faire des nodes pour les Ensembles de nombre
- *
- * !-> choses pour lesquelles la v1 ne marchera pas :
- *  !-- fractions non réduites
- *  !-- nbs décimaux avec des 0
- *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
- * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
- *
- * Passer les sqrtNode en tree-iable
- *
- *
- *
- * !!!à fix :
- * ! fraction réductible
- * ! 0,20 au lieu de 0,2
- * ! moins partout dans fraction
- * !puissances négatives vers inverse fraction
- * ! simplification du ln
- * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
- *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
- * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-
-*/
+import "./prototypesEnhancement";
 declare const mathExercises: (import("./exercises/exercise").Exercise<{
     numbers: number[];
 }> | import("./exercises/exercise").Exercise<{
@@ -642,38 +599,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     ineqSymbol: import("./math/inequations/inequation").InegalitySymbols;
     intervals: {
         a: number;
-        /**
-         * TODO
-         * Décimal : permettre facilement -0.xxx
-         * Tree shaking export
-         *
-         * VEA:
-         *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-         *      ->> faire le meme delire que pour les power mais pour les opposite ?
-         *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-         *  -> faire des nodes pour les Ensembles de nombre
-         *
-         * !-> choses pour lesquelles la v1 ne marchera pas :
-         *  !-- fractions non réduites
-         *  !-- nbs décimaux avec des 0
-         *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-         * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-         *
-         * Passer les sqrtNode en tree-iable
-         *
-         *
-         *
-         * !!!à fix :
-         * ! fraction réductible
-         * ! 0,20 au lieu de 0,2
-         * ! moins partout dans fraction
-         * !puissances négatives vers inverse fraction
-         * ! simplification du ln
-         * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-         *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-         * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-        
-        */
         b: number;
         closure: import("./tree/nodes/sets/closure").ClosureType;
     }[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/index.js

@@ -24,65 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pcExercises = exports.mathExercises = void 0;
-// import { exercises } from "./exercises/exercises";
-const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const MathExercises = __importStar(require("./exercises/math"));
 const PCExercises = __importStar(require("./exercises/pc"));
-const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
-const toScientific_1 = require("./utils/numberPrototype/toScientific");
-const variableNode_1 = require("./tree/nodes/variables/variableNode");
-String.prototype.unfrenchify = function () {
-    return Number(this.valueOf().replace(",", "."));
-};
-String.prototype.toTree = function () {
-    return new variableNode_1.VariableNode(this.valueOf());
-};
-Number.prototype.toTree = function () {
-    const value = this.valueOf();
-    if (value === Infinity)
-        return infiniteNode_1.PlusInfinityNode;
-    if (value === -Infinity)
-        return infiniteNode_1.MinusInfinityNode;
-    return new numberNode_1.NumberNode(value);
-};
-Number.prototype.frenchify = function () {
-    return (this.valueOf() + "").replace(".", ",");
-};
-Number.prototype.toScientific = function (decimals) {
-    return (0, toScientific_1.toScientific)(this.valueOf(), decimals);
-};
-/**
- * TODO
- * Décimal : permettre facilement -0.xxx
- * Tree shaking export
- *
- * VEA:
- *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
- *      ->> faire le meme delire que pour les power mais pour les opposite ?
- *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
- *  -> faire des nodes pour les Ensembles de nombre
- *
- * !-> choses pour lesquelles la v1 ne marchera pas :
- *  !-- fractions non réduites
- *  !-- nbs décimaux avec des 0
- *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
- * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
- *
- * Passer les sqrtNode en tree-iable
- *
- *
- *
- * !!!à fix :
- * ! fraction réductible
- * ! 0,20 au lieu de 0,2
- * ! moins partout dans fraction
- * !puissances négatives vers inverse fraction
- * ! simplification du ln
- * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
- *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
- * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-
-*/
+require("./prototypesEnhancement");
 const mathExercises = Object.values(MathExercises);
 exports.mathExercises = mathExercises;
 const pcExercises = Object.values(PCExercises);

package/lib/prototypesEnhancement.d.ts

@@ -0,0 +1,14 @@
+import { AlgebraicNode } from "./tree/nodes/algebraicNode";
+declare global {
+    interface Number {
+        toTree: () => AlgebraicNode;
+        frenchify: () => string;
+        toScientific: (decimals?: number) => AlgebraicNode;
+    }
+    interface String {
+        toTree: () => AlgebraicNode;
+        unfrenchify: () => number;
+    }
+}
+export {};
+//# sourceMappingURL=prototypesEnhancement.d.ts.map

package/lib/prototypesEnhancement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAS3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}

package/lib/prototypesEnhancement.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
+const numberNode_1 = require("./tree/nodes/numbers/numberNode");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
+const toScientific_1 = require("./utils/numberPrototype/toScientific");
+String.prototype.toTree = function () {
+    return new variableNode_1.VariableNode(this.valueOf());
+};
+String.prototype.unfrenchify = function () {
+    return Number(this.valueOf().replace(",", "."));
+};
+Number.prototype.toTree = function () {
+    const value = this.valueOf();
+    if (value === Infinity)
+        return infiniteNode_1.PlusInfinityNode;
+    if (value === -Infinity)
+        return infiniteNode_1.MinusInfinityNode;
+    return new numberNode_1.NumberNode(value);
+};
+Number.prototype.frenchify = function () {
+    return (this.valueOf() + "").replace(".", ",");
+};
+Number.prototype.toScientific = function (decimals) {
+    return (0, toScientific_1.toScientific)(this.valueOf(), decimals);
+};

package/lib/server.d.ts

@@ -1,13 +1,2 @@
-import { AlgebraicNode } from "./tree/nodes/algebraicNode";
-declare global {
-    interface Number {
-        toTree: () => AlgebraicNode;
-        frenchify: () => string;
-        toScientific: (decimals?: number) => AlgebraicNode;
-    }
-    interface String {
-        toTree: () => AlgebraicNode;
-        unfrenchify: () => number;
-    }
-}
+import "./prototypesEnhancement";
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAwC3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AA2CA,OAAO,yBAAyB,CAAC"}