Basic generation and improve validation

Author: khoi-nguyen

apps/test/src/App.tsx

@@ -4,7 +4,11 @@ import { Factor } from './Exercise'
 const App: Component = () => {
   const [data, setData] = createSignal({
     name: 'math/factor' as const,
-    question: { expr: '(x - 1)(x + 1)' },
+    question: { expr: '(x + {a})(x + {b})' },
+    params: {
+      a: [1, 2, 3],
+      b: [1, 2, 3],
+    },
     attempt: [],
   })
   return (

apps/test/src/Exercise.tsx

@@ -10,7 +10,18 @@ import { createMemo, Show } from 'solid-js'
 import * as v from 'valibot'
 
 const Math = defineField({
-  base: v.string(),
+  base: v.pipe(
+    v.string(),
+    v.nonEmpty(),
+    v.check((v) => {
+      try {
+        expr(v)
+        return true
+      } catch (error) {
+        return false
+      }
+    }, 'Expression mathématique invalide'),
+  ),
   feedback: v.pipe(v.string(), v.transform(expr)),
 })
 

packages/core/src/exercise/base.tsx

@@ -1,5 +1,5 @@
 import { Dynamic } from '@solidjs/web'
-import { mapAsync, mapValues } from 'es-toolkit'
+import { mapAsync, mapValues, sample } from 'es-toolkit'
 import {
   createMemo,
   createStore,
@@ -147,19 +147,50 @@ function Attempt<T extends Schema, V extends 'base' | 'feedback'>(schema: T, sta
   )
 }
 
+function Param<T extends boolean>(transform: T) {
+  const value = v.union([v.number(), v.string()])
+  const base = v.array(value)
+  const withTransform = v.pipe(base, v.transform(sample))
+  return (transform ? withTransform : base) as T extends true ? typeof withTransform : typeof base
+}
+
+function Params<T extends boolean>(transform: T) {
+  return v.record(v.string(), Param(transform))
+}
+
 export function buildSchemas<T extends Schema>(
   schema: T,
   feedback: ReturnType<typeof defineFeedback<T>>,
 ) {
   return {
+    Teacher: v.object({
+      name: v.literal(schema.name as T['name']),
+      question: RawShapeSchema(schema.question as T['question'], 'base'),
+      params: v.optional(Params(false)),
+    }),
     Student: v.pipeAsync(
       v.object({
         name: v.literal(schema.name as T['name']),
         question: RawShapeSchema(schema.question as T['question'], 'base'),
         attempt: Attempt(schema, 'base'),
+        params: v.optional(Params(true)),
       }),
       // TODO: calls need to be deduped, waiting for solid-router release?
-      v.transformAsync(async ({ attempt, question, ...exercise }) => {
+      v.transformAsync(async ({ attempt, question: q, params, ...exercise }) => {
+        let question = q
+        function subs<T extends any>(param: string, value: string, v: T): T {
+          if (typeof v === 'string') {
+            return v.replaceAll(`{${param}}`, value) as T
+          } else if (Array.isArray(v)) {
+            return v.map(subs.bind(null, param, value)) as T
+          } else if (typeof v === 'object' && v !== null) {
+            return mapValues(v, subs.bind(null, param, value)) as T
+          }
+          return v
+        }
+        for (const [param, value] of Object.entries(params ?? {})) {
+          question = subs(param, String(value), question)
+        }
         const parsedQuestion = v.parse(
           RawShapeSchema(schema.question as T['question'], 'feedback'),
           question,

packages/core/src/expr.ts

@@ -20,6 +20,7 @@ const integrateParams = v.union([
 const Math: v.GenericSchema<MathJsonExpression> = v.union([
   v.pipe(
     v.string(),
+    v.check((expr) => ce.parse(expr).isValid, "Ceci n'est pas une expression mathématique valide"),
     v.transform((input) => ce.parse(input).json),
   ),
   v.number(),