@erudit-js/prose 4.0.0 → 4.1.0

package/dist/elements/problem/problemCheck.js

@@ -0,0 +1,203 @@
+import { defineRegistryItem, defineSchema, ensureTagChildren, ProseError } from "@jsprose/core";
+import { defineEruditTag } from "../../tag.js";
+import { defineEruditProseCoreElement } from "../../coreElement.js";
+export const problemCheckSchema = defineSchema({
+	name: "problemCheck",
+	type: "block",
+	linkable: false
+})();
+export const ProblemCheck = defineEruditTag({
+	tagName: "ProblemCheck",
+	schema: problemCheckSchema
+})(({ element, tagName, props, children }) => {
+	//
+	// Info
+	//
+	const checkInfo = {
+		label: props.label,
+		hint: props.hint,
+		placeholder: props.placeholder
+	};
+	//
+	// Children
+	//
+	if (children && children.length > 0) {
+		ensureTagChildren(tagName, children, problemCheckSchema);
+		element.children = children;
+	}
+	//
+	// Validator
+	//
+	let validator;
+	if ("yes" in props) {
+		validator = {
+			type: "boolean",
+			answer: true
+		};
+	} else if ("no" in props) {
+		validator = {
+			type: "boolean",
+			answer: false
+		};
+	} else if ("answer" in props) {
+		validator = {
+			type: "value",
+			answer: props.answer
+		};
+	} else if ("answers" in props) {
+		const answersProp = props.answers;
+		let ordered = false;
+		let separator = ",";
+		let answers;
+		if (Array.isArray(answersProp)) {
+			answers = answersProp;
+		} else {
+			ordered = answersProp.ordered ?? false;
+			separator = answersProp.separator ?? ",";
+			answers = answersProp.values;
+		}
+		validator = {
+			type: "array",
+			ordered,
+			separator,
+			answers
+		};
+	} else if ("script" in props) {
+		validator = {
+			type: "script",
+			name: props.script
+		};
+	}
+	element.data = {
+		...checkInfo,
+		serializedValidator: toSerializableValidator(validator)
+	};
+});
+export const problemCheckRegistryItem = defineRegistryItem({
+	schema: problemCheckSchema,
+	tags: [ProblemCheck]
+});
+export const problemCheckCoreElement = defineEruditProseCoreElement({ registryItem: problemCheckRegistryItem });
+export function toSerializableValidator(validator) {
+	if (validator.type === "boolean") {
+		return validator;
+	}
+	const toSerializableValue = (value) => {
+		if (value instanceof RegExp) {
+			return {
+				type: "regexp",
+				source: value.source,
+				flags: value.flags
+			};
+		}
+		return value;
+	};
+	if (validator.type === "value") {
+		return {
+			type: "value",
+			answer: toSerializableValue(validator.answer)
+		};
+	}
+	if (validator.type === "array") {
+		return {
+			type: "array",
+			ordered: validator.ordered,
+			separator: validator.separator,
+			answers: validator.answers.map((answer) => {
+				if (Array.isArray(answer)) {
+					return answer.map(toSerializableValue);
+				}
+				return toSerializableValue(answer);
+			})
+		};
+	}
+	if (validator.type === "script") {
+		return validator;
+	}
+	throw new Error(`Unknown ProblemCheckData type "${validator.type}"!`);
+}
+export function fromSerializableValidator(serializedValidator) {
+	if (serializedValidator.type === "boolean") {
+		return serializedValidator;
+	}
+	const fromSerializableValue = (value) => {
+		if (value && value.type === "regexp") {
+			return new RegExp(value.source, value.flags);
+		}
+		return value;
+	};
+	if (serializedValidator.type === "value") {
+		return {
+			type: "value",
+			answer: fromSerializableValue(serializedValidator.answer)
+		};
+	}
+	if (serializedValidator.type === "array") {
+		return {
+			type: "array",
+			ordered: serializedValidator.ordered,
+			separator: serializedValidator.separator,
+			answers: serializedValidator.answers.map((answer) => {
+				if (Array.isArray(answer)) {
+					return answer.map(fromSerializableValue);
+				}
+				return fromSerializableValue(answer);
+			})
+		};
+	}
+	if (serializedValidator.type === "script") {
+		return serializedValidator;
+	}
+	throw new Error(`Unknown ProblemCheckData type "${serializedValidator.type}"!`);
+}
+export function checkProblemAnswer(answer, yesRegexp, noRegexp, validator) {
+	if (validator.type === "boolean") {
+		return validator.answer === true ? yesRegexp.test(answer) : noRegexp.test(answer);
+	}
+	const checkDefinedAnswer = (expected, answer) => {
+		if (typeof expected === "number") {
+			return Number(answer) === expected;
+		}
+		if (expected instanceof RegExp) {
+			return expected.test(answer);
+		}
+		return answer === String(expected);
+	};
+	const checkAnswer = (expect, answer) => {
+		if (expect === undefined) {
+			return answer.trim() === "";
+		}
+		return checkDefinedAnswer(expect, answer);
+	};
+	if (validator.type === "value") {
+		return checkAnswer(validator.answer, answer);
+	}
+	if (validator.type === "array") {
+		const separatorRegexp = new RegExp(`\\s*${validator.separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*`, "g");
+		const parts = answer.split(separatorRegexp).map((p) => p.trim());
+		const checkExpected = (expected, actual) => {
+			if (Array.isArray(expected)) {
+				// any-of logic
+				return expected.some((e) => checkDefinedAnswer(e, actual));
+			}
+			return checkDefinedAnswer(expected, actual);
+		};
+		if (parts.length !== validator.answers.length) {
+			return false;
+		}
+		if (validator.ordered) {
+			return validator.answers.every((expected, i) => checkExpected(expected, parts[i]));
+		}
+		// unordered matching (multiset semantics)
+		const remaining = [...parts];
+		for (const expected of validator.answers) {
+			const index = remaining.findIndex((actual) => checkExpected(expected, actual));
+			if (index === -1) {
+				return false;
+			}
+			remaining.splice(index, 1);
+		}
+		return true;
+	}
+	throw new ProseError(`"checkProblemAnswer" not implemented for type "${validator.type}"!`);
+}

package/dist/elements/problem/problemContent.d.ts

@@ -1,4 +1,5 @@
-import { type AnySchema, type BlockSchema, type NormalizedChildren, type NoTagChildren, type TagChildren } from '@jsprose/core';
+import { type AnySchema, type NormalizedChildren, type TagChildren } from '@jsprose/core';
+import { problemCheckSchema } from './problemCheck.js';
 export declare const problemDescription: {
     schema: {
         name: "problemDescription";
@@ -425,124 +426,5 @@ export declare const problemAnswer: {
         }, undefined>;
     };
 };
-export type CheckFunction = (args: {
-    answer: string | undefined;
-    name: string;
-    answers: Record<string, string | undefined>;
-}) => boolean;
-export interface ProblemCheckRegex {
-    pattern: string;
-    flags: string;
-}
-export type ProblemCheckValue = string | ProblemCheckRegex | undefined;
-export type ProblemCheckSetValue = string | ProblemCheckRegex;
-export interface ProblemCheckData {
-    label?: string;
-    hint?: string;
-    placeholder?: string;
-    answers?: ProblemCheckValue[];
-    set?: {
-        separator: string;
-        values: (ProblemCheckSetValue | ProblemCheckSetValue[])[];
-    };
-    script?: string;
-}
-type Answer = string | number | RegExp | undefined;
-export declare function checkValue(input: string | undefined, data: ProblemCheckData): boolean;
-export declare const problemCheckSchema: {
-    name: "problemCheck";
-    type: "block";
-    linkable: false;
-    Data: ProblemCheckData;
-    Storage: undefined;
-    Children: BlockSchema[];
-};
-type UndefinedOnly<T> = {
-    [K in keyof T]?: undefined;
-};
-type OneOf<T extends Record<string, any>> = {
-    [K in keyof T]: Pick<T, K> & UndefinedOnly<Omit<T, K>>;
-}[keyof T];
-export declare const ProblemCheck: import("@jsprose/core").Tag<"ProblemCheck", {
-    name: "problemCheck";
-    type: "block";
-    linkable: false;
-    Data: ProblemCheckData;
-    Storage: undefined;
-    Children: BlockSchema[];
-}, ({
-    label?: string;
-    hint?: string;
-    placeholder?: string;
-} & (OneOf<{
-    answer: Answer;
-    answers: Answer[];
-    set: (Answer | Answer[])[] | {
-        separator: string;
-        values: (Answer | Answer[])[];
-    };
-    script: string;
-}> & (TagChildren | NoTagChildren))) & {}>;
-export declare const problemCheckRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "problemCheck";
-    type: "block";
-    linkable: false;
-    Data: ProblemCheckData;
-    Storage: undefined;
-    Children: BlockSchema[];
-}, {
-    ProblemCheck: import("@jsprose/core").Tag<"ProblemCheck", {
-        name: "problemCheck";
-        type: "block";
-        linkable: false;
-        Data: ProblemCheckData;
-        Storage: undefined;
-        Children: BlockSchema[];
-    }, ({
-        label?: string;
-        hint?: string;
-        placeholder?: string;
-    } & (OneOf<{
-        answer: Answer;
-        answers: Answer[];
-        set: (Answer | Answer[])[] | {
-            separator: string;
-            values: (Answer | Answer[])[];
-        };
-        script: string;
-    }> & (TagChildren | NoTagChildren))) & {}>;
-}, undefined>;
-export declare const problemCheckCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemCheck";
-        type: "block";
-        linkable: false;
-        Data: ProblemCheckData;
-        Storage: undefined;
-        Children: BlockSchema[];
-    }, {
-        ProblemCheck: import("@jsprose/core").Tag<"ProblemCheck", {
-            name: "problemCheck";
-            type: "block";
-            linkable: false;
-            Data: ProblemCheckData;
-            Storage: undefined;
-            Children: BlockSchema[];
-        }, ({
-            label?: string;
-            hint?: string;
-            placeholder?: string;
-        } & (OneOf<{
-            answer: Answer;
-            answers: Answer[];
-            set: (Answer | Answer[])[] | {
-                separator: string;
-                values: (Answer | Answer[])[];
-            };
-            script: string;
-        }> & (TagChildren | NoTagChildren))) & {}>;
-    }, undefined>;
-};
 export type ProblemContentChild = typeof problemDescriptionSchema | typeof problemHintSchema | typeof problemNote.schema | typeof problemSolution.schema | typeof problemAnswer.schema | typeof problemCheckSchema;
 export declare function validateProblemContent(source: string, children: NormalizedChildren): void;
-export {};

package/dist/elements/problem/problemContent.js

@@ -1,20 +1,9 @@
-//
-// <Problem>
-//   <ProblemDescription />
-//   <ProblemHint />
-//   <ProblemNote>
-//     <ProblemSection title="..." />
-//   </ProblemNote>
-//   <ProblemSolution />
-//   <ProblemAnswer />
-//   <ProblemCheck />
-// </Problem>
-//
-import { defineRegistryItem, defineSchema, ensureTagChildren, ensureTagNoChildren, isRawElement, ProseError } from "@jsprose/core";
+import { defineRegistryItem, defineSchema, ensureTagChildren, isRawElement, ProseError } from "@jsprose/core";
 import { defineEruditTag } from "../../tag.js";
 import { defineEruditProseCoreElement } from "../../coreElement.js";
 import { uppercaseFirst } from "../../utils/case.js";
 import { tryParagraphWrap } from "../../shared/paragraphWrap.js";
+import { problemCheckSchema } from "./problemCheck.js";
 /* --------------------------------------------------------- */
 /* shared helpers                                            */
 /* --------------------------------------------------------- */
@@ -128,120 +117,6 @@ function defineProblemSectionContainer(name) {
 export const problemNote = defineProblemSectionContainer("note");
 export const problemSolution = defineProblemSectionContainer("solution");
 export const problemAnswer = defineProblemSectionContainer("answer");
-function normalizeValue(v) {
-	if (v === undefined) return undefined;
-	if (v instanceof RegExp) {
-		return {
-			pattern: v.source,
-			flags: v.flags
-		};
-	}
-	return String(v);
-}
-function safeRegexTest(re, value) {
-	try {
-		return new RegExp(re.pattern, re.flags).test(value);
-	} catch {
-		return false;
-	}
-}
-function matchSingle(value, expected) {
-	// Handle null as undefined (from JSON serialization)
-	const normalizedExpected = expected === null ? undefined : expected;
-	const normalizedValue = value === null ? undefined : value;
-	if (normalizedExpected === undefined) return normalizedValue === undefined;
-	if (typeof normalizedExpected === "string") return normalizedValue === normalizedExpected;
-	if (normalizedValue === undefined) return false;
-	return safeRegexTest(normalizedExpected, normalizedValue);
-}
-function matchSet(value, set) {
-	const sep = new RegExp(`\\s*${set.separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*`);
-	const inputs = value.split(sep).filter(Boolean);
-	if (inputs.length !== set.values.length) return false;
-	const canMatch = (v, expected) => Array.isArray(expected) ? expected.some((e) => typeof e === "string" ? v === e : safeRegexTest(e, v)) : typeof expected === "string" ? v === expected : safeRegexTest(expected, v);
-	const adj = inputs.map((v) => set.values.map((e, i) => canMatch(v, e) ? i : -1).filter((i) => i !== -1));
-	const match = new Array(set.values.length).fill(-1);
-	const dfs = (u, seen) => adj[u].some((v) => {
-		if (seen[v]) return false;
-		seen[v] = true;
-		return match[v] === -1 || dfs(match[v], seen) ? (match[v] = u, true) : false;
-	});
-	return inputs.every((_, i) => dfs(i, new Array(set.values.length).fill(false)));
-}
-export function checkValue(input, data) {
-	const normalized = input?.trim().replace(/\s+/g, " ") || undefined;
-	if (data.answers) {
-		return data.answers.some((a) => matchSingle(normalized, a));
-	}
-	if (data.set && normalized !== undefined) {
-		return matchSet(normalized, data.set);
-	}
-	return false;
-}
-/* --------------------------------------------------------- */
-/* problem check tag                                         */
-/* --------------------------------------------------------- */
-export const problemCheckSchema = defineSchema({
-	name: "problemCheck",
-	type: "block",
-	linkable: false
-})();
-export const ProblemCheck = defineEruditTag({
-	tagName: "ProblemCheck",
-	schema: problemCheckSchema
-})(({ element, tagName, props, children }) => {
-	if (children && children.length > 0) {
-		ensureTagChildren(tagName, children, problemCheckSchema);
-		element.children = children;
-	} else {
-		ensureTagNoChildren(tagName, children);
-	}
-	const data = {};
-	if ("answer" in props) {
-		data.answers = [normalizeValue(props.answer)];
-	} else if ("answers" in props) {
-		data.answers = props.answers.map(normalizeValue);
-	} else if ("script" in props) {
-		data.script = props.script;
-	} else if ("set" in props) {
-		const normalizeSetItem = (v) => {
-			if (Array.isArray(v)) {
-				return v.map((x) => {
-					const nv = normalizeValue(x);
-					if (!nv) {
-						throw new ProseError(`${tagName}: undefined not allowed in set values.`);
-					}
-					return nv;
-				});
-			}
-			const nv = normalizeValue(v);
-			if (!nv) {
-				throw new ProseError(`${tagName}: undefined not allowed in set values.`);
-			}
-			return nv;
-		};
-		if (Array.isArray(props.set)) {
-			data.set = {
-				separator: ",",
-				values: props.set.map(normalizeSetItem)
-			};
-		} else {
-			data.set = {
-				separator: props.set.separator,
-				values: props.set.values.map(normalizeSetItem)
-			};
-		}
-	}
-	if (props.label !== undefined) data.label = props.label;
-	if (props.hint !== undefined) data.hint = props.hint;
-	if (props.placeholder !== undefined) data.placeholder = props.placeholder;
-	element.data = data;
-});
-export const problemCheckRegistryItem = defineRegistryItem({
-	schema: problemCheckSchema,
-	tags: [ProblemCheck]
-});
-export const problemCheckCoreElement = defineEruditProseCoreElement({ registryItem: problemCheckRegistryItem });
 export function validateProblemContent(source, children) {
 	ensureTagChildren(source, children, [
 		problemDescriptionSchema,

package/dist/elements/problem/problemScript.d.ts

@@ -1,6 +1,11 @@
 import { type AnySchema, type AnyUnique, type AutoUnique, type LinkableTag, type RawElement, type Unique, type WrapSchemas } from '@jsprose/core';
 import { type ProblemSeed, ProblemRandom } from './rng.js';
-import { type CheckFunction, type ProblemContentChild } from './problemContent.js';
+import { type ProblemContentChild } from './problemContent.js';
+export type CheckFunction = (args: {
+    answer: string | undefined;
+    name: string;
+    answers: Record<string, string | undefined>;
+}) => boolean;
 export declare function insertProblemScriptId(scriptSrc: string, code: string): string;
 export interface ProblemScriptDefinition {
     uniques?: Record<string, LinkableTag>;

package/dist/elements/table/Table.vue

@@ -1,100 +1,100 @@
-<script lang="ts" setup>
-import { computed } from 'vue';
-import { isProseElement, type ProseElement } from '@jsprose/core';
-
-import type { tableSchema } from './core.js';
-import { captionSchema } from '../caption/core.js';
-import Render from '../../app/shared/Render.vue';
-import Block from '../../app/shared/block/Block.vue';
-import Caption from '../caption/Caption.vue';
-
-const { element } = defineProps<{
-  element: ProseElement<typeof tableSchema>;
-}>();
-
-const caption = computed(() => {
-  const maybeCaption = element.children[element.children.length - 1];
-  return isProseElement(maybeCaption, captionSchema) ? maybeCaption : undefined;
-});
-
-const rows = computed(() =>
-  caption.value ? element.children.slice(0, -1) : element.children,
-);
-</script>
-
-<template>
-  <Block :element>
-    <div class="nice-scrollbars overflow-auto">
-      <table
-        :class="[
-          $style.table,
-          `text-main-sm bg-bg-main m-auto max-w-full border-separate
-          border-spacing-[3px] rounded border border-(--tableBorder)`,
-        ]"
-      >
-        <tbody>
-          <tr
-            v-for="row in rows"
-            :key="row.id"
-            class="odd:bg-(--oddCellBg) even:bg-(--evenCellBg)"
-          >
-            <td
-              v-for="cell in row.children"
-              :key="cell.id"
-              class="py-small px-normal rounded"
-            >
-              <Render
-                v-for="inliner of cell.children"
-                :key="inliner.id"
-                :element="inliner"
-              />
-            </td>
-          </tr>
-        </tbody>
-      </table>
-    </div>
-    <Caption v-if="caption" :caption="caption" />
-  </Block>
-</template>
-
-<style module>
-.table {
-  --tableBorder: color-mix(
-    in srgb,
-    var(--color-brand),
-    var(--color-border) 85%
-  );
-
-  --evenCellBg: color-mix(
-    in srgb,
-    light-dark(#f5f5f5, #282828),
-    var(--color-brand) 3%
-  );
-
-  --oddCellBg: color-mix(
-    in srgb,
-    light-dark(#f5f5f5, #282828),
-    var(--color-brand) 10%
-  );
-
-  [data-prose-accent] & {
-    --tableBorder: color-mix(
-      in srgb,
-      var(--accentBorder),
-      var(--color-border) 50%
-    );
-
-    --evenCellBg: color-mix(
-      in srgb,
-      light-dark(var(--color-bg-main), #202020),
-      var(--accentText) 12%
-    );
-
-    --oddCellBg: color-mix(
-      in srgb,
-      light-dark(var(--color-bg-main), #202020),
-      var(--accentText) 18%
-    );
-  }
-}
-</style>
+<script lang="ts" setup>
+import { computed } from 'vue';
+import { isProseElement, type ProseElement } from '@jsprose/core';
+
+import type { tableSchema } from './core.js';
+import { captionSchema } from '../caption/core.js';
+import Render from '../../app/shared/Render.vue';
+import Block from '../../app/shared/block/Block.vue';
+import Caption from '../caption/Caption.vue';
+
+const { element } = defineProps<{
+  element: ProseElement<typeof tableSchema>;
+}>();
+
+const caption = computed(() => {
+  const maybeCaption = element.children[element.children.length - 1];
+  return isProseElement(maybeCaption, captionSchema) ? maybeCaption : undefined;
+});
+
+const rows = computed(() =>
+  caption.value ? element.children.slice(0, -1) : element.children,
+);
+</script>
+
+<template>
+  <Block :element>
+    <div class="nice-scrollbars overflow-auto">
+      <table
+        :class="[
+          $style.table,
+          `text-main-sm bg-bg-main m-auto max-w-full border-separate
+          border-spacing-[3px] rounded border border-(--tableBorder)`,
+        ]"
+      >
+        <tbody>
+          <tr
+            v-for="row in rows"
+            :key="row.id"
+            class="odd:bg-(--oddCellBg) even:bg-(--evenCellBg)"
+          >
+            <td
+              v-for="cell in row.children"
+              :key="cell.id"
+              class="py-small px-normal rounded"
+            >
+              <Render
+                v-for="inliner of cell.children"
+                :key="inliner.id"
+                :element="inliner"
+              />
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <Caption v-if="caption" :caption="caption" />
+  </Block>
+</template>
+
+<style module>
+.table {
+  --tableBorder: color-mix(
+    in srgb,
+    var(--color-brand),
+    var(--color-border) 85%
+  );
+
+  --evenCellBg: color-mix(
+    in srgb,
+    light-dark(#f5f5f5, #282828),
+    var(--color-brand) 3%
+  );
+
+  --oddCellBg: color-mix(
+    in srgb,
+    light-dark(#f5f5f5, #282828),
+    var(--color-brand) 10%
+  );
+
+  [data-prose-accent] & {
+    --tableBorder: color-mix(
+      in srgb,
+      var(--accentBorder),
+      var(--color-border) 50%
+    );
+
+    --evenCellBg: color-mix(
+      in srgb,
+      light-dark(var(--color-bg-main), #202020),
+      var(--accentText) 12%
+    );
+
+    --oddCellBg: color-mix(
+      in srgb,
+      light-dark(var(--color-bg-main), #202020),
+      var(--accentText) 18%
+    );
+  }
+}
+</style>