;
- passthroughChildren: true;
-} & CommonProps;
-
-/**
- * A map of tag names to components. This is used for naive component rendering, where the
- * tag name uniquely determines the component to render.
- */
-const TEXT_MODE_COMPONENTS: Record<
- string,
- Component | ComponentWithPassthroughChildren
-> = {
- answer: { component: Answer },
- choiceInput: { component: ChoiceInput },
- p: { component: P, passthroughChildren: true },
- document: { component: Document, passthroughChildren: true },
- m: { component: M, passthroughChildren: true },
- math: { component: Math },
- graph: { component: Graph },
- division: {
- component: Division,
- passthroughChildren: true,
- monitorVisibility: true,
- },
- problem: {
- component: Problem,
- passthroughChildren: true,
- monitorVisibility: true,
- },
- textInput: { component: TextInput },
- text: { component: Text },
- boolean: { component: Boolean },
- title: { component: Title, passthroughChildren: true },
- _fragment: { component: _Fragment, passthroughChildren: true },
- xref: { component: Xref, passthroughChildren: true },
- ol: { component: Ol, passthroughChildren: true },
- ul: { component: Ul, passthroughChildren: true },
- li: { component: Li, passthroughChildren: true },
-
- // For PreTeXt compatibility
- pretext: { component: _Fragment, passthroughChildren: true },
- article: { component: _Fragment, passthroughChildren: true },
- book: { component: _Fragment, passthroughChildren: true },
-};
-
-const GRAPH_MODE_COMPONENTS: Record<
- string,
- Component | ComponentWithPassthroughChildren
-> = {
- line: { component: LineInGraph },
- point: { component: PointInGraph },
-};
-
/**
* Generate a component that will render nothing but will log a warning to the console.
*/
@@ -109,8 +28,14 @@ function makeNullComponentWithMessage(message: string) {
export function getComponent(
node: FlatDastElement,
constraint?: ComponentConstraint,
-): (typeof TEXT_MODE_COMPONENTS)[keyof typeof TEXT_MODE_COMPONENTS] {
+ renderers: {
+ textMode: RendererObject;
+ graphMode: RendererObject;
+ } = { textMode: TEXT_MODE_COMPONENTS, graphMode: GRAPH_MODE_COMPONENTS },
+): RendererObject[keyof RendererObject] {
constraint = constraint ?? "text";
+ const TEXT_MODE_COMPONENTS = renderers.textMode;
+ const GRAPH_MODE_COMPONENTS = renderers.graphMode;
const componentLookup =
constraint === "text"
@@ -119,7 +44,8 @@ export function getComponent(
? GRAPH_MODE_COMPONENTS
: TEXT_MODE_COMPONENTS;
- const component = componentLookup[node?.name];
+ const component =
+ componentLookup[node?.name] ?? componentLookup[FALLBACK_RENDERER_KEY];
if (!component) {
return {
component: makeNullComponentWithMessage(
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/README.md b/packages/doenetml-prototype/src/renderers/pretext-xml/README.md
new file mode 100644
index 000000000..3befae4e2
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/README.md
@@ -0,0 +1,4 @@
+# Pretext Components
+
+These components are for rendering to PreTeXt XML (not for a webpage, but
+for recompilation with the PreTeXt compiler).
\ No newline at end of file
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/_fragment.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/_fragment.tsx
new file mode 100644
index 000000000..9039fb6f7
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/_fragment.tsx
@@ -0,0 +1,12 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+
+/**
+ * A _Fragment component is a special component that cannot be directly authored.
+ * It is meant to display references to existing content.
+ */
+export const _Fragment: BasicComponentWithPassthroughChildren<{}> = ({
+ children,
+}) => {
+ return {children};
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag-and-newline.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag-and-newline.tsx
new file mode 100644
index 000000000..7a11244f4
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag-and-newline.tsx
@@ -0,0 +1,17 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import { _PassThroughWithTag } from "./_pass-through-with-tag";
+
+/**
+ * Same as `_PassThroughWithTag` except inserts newlines before and after the children.
+ */
+export const _PassThroughWithTagAndNewline: BasicComponentWithPassthroughChildren<{}> =
+ ({ children, ...rest }) => {
+ return (
+ <_PassThroughWithTag {...rest}>
+ {"\n"}
+ {children}
+ {"\n"}
+
+ );
+ };
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag.tsx
new file mode 100644
index 000000000..d78b944f0
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/_pass-through-with-tag.tsx
@@ -0,0 +1,18 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import { normalizeAttrs } from "../../utils/pretext/normalize-attrs";
+
+/**
+ * A _PassThroughWithTag component is a special component that cannot be directly authored.
+ * It will render `node` in directly as an XML element with the same name (e.g. if `node.name` is "p", it will render ``).
+ */
+export const _PassThroughWithTag: BasicComponentWithPassthroughChildren<{}> = ({
+ children,
+ node,
+}) => {
+ return React.createElement(
+ node.name,
+ normalizeAttrs(node.attributes),
+ children,
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/answer.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/answer.tsx
new file mode 100644
index 000000000..ea47ba6c0
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/answer.tsx
@@ -0,0 +1,19 @@
+import React from "react";
+import { BasicComponent } from "../types";
+import { useAppSelector } from "../../state/hooks";
+import { renderingOnServerSelector } from "../../state/redux-slices/global";
+
+export const Answer: BasicComponent = ({ node }) => {
+ const onServer = useAppSelector(renderingOnServerSelector);
+ if (onServer) {
+ return ;
+ }
+ return (
+
+
+
+
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/boolean.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/boolean.tsx
new file mode 100644
index 000000000..fc0f99acd
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/boolean.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { BasicComponent } from "../types";
+import type { BooleanProps } from "@doenet/doenetml-worker-rust";
+
+type BooleanData = { props: BooleanProps };
+
+export const Boolean: BasicComponent = ({ node }) => {
+ return {node.data.props.value.toString()};
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/choice-input.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/choice-input.tsx
new file mode 100644
index 000000000..2e315a2b0
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/choice-input.tsx
@@ -0,0 +1,6 @@
+import React from "react";
+import { BasicComponent } from "../types";
+
+export const ChoiceInput: BasicComponent = ({ node }) => {
+ return null;
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/division.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/division.tsx
new file mode 100644
index 000000000..455591e76
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/division.tsx
@@ -0,0 +1,40 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import { Element } from "../element";
+import type { DivisionProps } from "@doenet/doenetml-worker-rust";
+import { generateHtmlId } from "../utils";
+
+export const Division: BasicComponentWithPassthroughChildren<{
+ props: DivisionProps;
+}> = ({ children, node, annotation, ancestors }) => {
+ const htmlId = generateHtmlId(node, annotation, ancestors);
+ const titleElmId = node.data.props.title;
+ const divisionType = node.data.props.divisionType;
+
+ // If the node had a name, we want to put an `xml:id` attribute on the element
+ // We use `htmlId` as the value of the `xml:id` attribute because it will always be globally unique
+ // as required by PreTeXt
+ const xmlId = node.name && htmlId;
+
+ const additionalAttrs = { "xml:id": xmlId };
+
+ const title =
+ titleElmId != null ? (
+ // We put a newline before a title just to make the formatting of the document look a little better
+
+ {"\n "}
+
+
+ ) : (
+ ""
+ );
+
+ return React.createElement(
+ divisionType,
+ { ...node.attributes, ...additionalAttrs },
+
+ {title}
+ {children}
+ ,
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/graph.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/graph.tsx
new file mode 100644
index 000000000..b27fa77b4
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/graph.tsx
@@ -0,0 +1,217 @@
+import React from "react";
+import {
+ VscChevronDown,
+ VscChevronLeft,
+ VscChevronRight,
+ VscChevronUp,
+ VscScreenNormal,
+ VscTarget,
+ VscZoomIn,
+ VscZoomOut,
+} from "react-icons/vsc";
+import * as JSG from "jsxgraph";
+import { JSXGraph } from "jsxgraph";
+import { BasicComponent } from "../types";
+import { Toolbar, ToolbarItem } from "@ariakit/react";
+import { Element } from "../element";
+
+export const GraphContext = React.createContext(null);
+
+/**
+ * Which layer each type of element is to be drawn on. These layers determine what shows up on top of what.
+ *
+ * NOTE: there can be at most 10 different layer offsets,
+ * given that the DoenetML layer is multiplied by 10 and added to these offsets
+ */
+export const LAYER_OFFSETS = {
+ base: 0,
+ image: 1,
+ line: 2,
+ vertex: 3,
+ controlPoint: 4,
+ point: 5,
+ text: 6,
+};
+
+export const Graph: BasicComponent = ({ node }) => {
+ const boardId = "jsxgraph-board-" + node.data.id;
+ const boardRef = React.useRef(null);
+ const [board, setBoard] = React.useState(null);
+ const [xaxis, setXaxis] = React.useState(null);
+ const [yaxis, setYaxis] = React.useState(null);
+
+ React.useLayoutEffect(() => {
+ if (!boardRef.current) {
+ return;
+ }
+ const board = JSXGraph.initBoard(boardRef.current, {
+ axis: false,
+ grid: false,
+ showNavigation: false,
+ showCopyright: false,
+ boundingBox: [-5, 5, 5, -5],
+ // Sometimes needed to keep the board from continually expanding
+ resize: { enabled: false, throttle: 100 },
+ });
+
+ const xaxis = board.create(
+ "axis",
+ [
+ [0, 0],
+ [1, 0],
+ ],
+ {
+ ticks: {
+ visible: true,
+ majorHeight: 10,
+ minorHeight: 5,
+ strokeColor: "var(--canvastext)",
+ strokeWidth: 1,
+ },
+ highlight: false,
+ strokeColor: "var(--canvastext)",
+ },
+ );
+ setXaxis(xaxis);
+ const yaxis = board.create(
+ "axis",
+ [
+ [0, 0],
+ [0, 1],
+ ],
+ {
+ ticks: {
+ visible: true,
+ majorHeight: 10,
+ minorHeight: 5,
+ strokeColor: "var(--canvastext)",
+ strokeWidth: 1,
+ },
+ highlight: false,
+ strokeColor: "var(--canvastext)",
+ },
+ );
+ setYaxis(yaxis);
+
+ setBoard(board);
+ }, [boardRef]);
+
+ const elementChildrenIds = React.useMemo(
+ () =>
+ node.children
+ .filter((n) => typeof n === "object" && "id" in n)
+ .map((n) => (n as any).id) as number[],
+ [node.children],
+ );
+
+ return (
+
+
+
+ {elementChildrenIds.map((id) => (
+
+ ))}
+
+
+
+
+ {
+ board.zoomOut();
+ }}
+ >
+
+
+ {
+ board.zoom100();
+ }}
+ >
+
+
+ {
+ board.zoomIn();
+ }}
+ >
+
+
+
+
+ {
+ board.clickLeftArrow();
+ }}
+ >
+
+
+ {
+ board.clickRightArrow();
+ }}
+ >
+
+
+ {
+ board.clickDownArrow();
+ }}
+ >
+
+
+ {
+ board.clickUpArrow();
+ }}
+ >
+
+
+ {
+ const [xmin, ymax, xmax, ymin] = board.getBoundingBox();
+ const width = xmax - xmin;
+ const height = ymax - ymin;
+
+ board.setBoundingBox([
+ -width / 2,
+ height / 2,
+ width / 2,
+ -height / 2,
+ ]);
+ }}
+ >
+
+
+
+
+ );
+}
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/index.ts b/packages/doenetml-prototype/src/renderers/pretext-xml/index.ts
new file mode 100644
index 000000000..4dca19d69
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/index.ts
@@ -0,0 +1,21 @@
+export * from "./p";
+export * from "./m";
+export * from "./math";
+export * from "./graph";
+export * from "./division";
+export * from "./problem";
+export * from "./answer";
+export * from "./text-input";
+export * from "./line";
+export * from "./point";
+export * from "./text";
+export * from "./boolean";
+export * from "./title";
+export * from "./_fragment";
+export * from "./xref";
+export * from "./ol";
+export * from "./ul";
+export * from "./li";
+export * from "./choice-input";
+export * from "./_pass-through-with-tag";
+export * from "./_pass-through-with-tag-and-newline";
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/jsxgraph/listeners.ts b/packages/doenetml-prototype/src/renderers/pretext-xml/jsxgraph/listeners.ts
new file mode 100644
index 000000000..c010606e6
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/jsxgraph/listeners.ts
@@ -0,0 +1,56 @@
+import * as JSG from "jsxgraph";
+
+type InteractionState = {
+ dragActive: boolean;
+ pointerAtDown: [number, number];
+ pointerIsDown: boolean;
+};
+
+export function attachStandardGraphListeners(
+ obj: T,
+) {
+ const interactionState: InteractionState = {
+ dragActive: false,
+ pointerAtDown: [0, 0],
+ pointerIsDown: false,
+ };
+
+ obj.on("drag", function (_e) {
+ const e = _e as MouseEvent;
+ const viaPointer = e.type === "pointermove";
+
+ // Protect against very small unintended drags
+ if (
+ !viaPointer ||
+ Math.abs(e.x - interactionState.pointerAtDown[0]) > 0.1 ||
+ Math.abs(e.y - interactionState.pointerAtDown[1]) > 0.1
+ ) {
+ interactionState.dragActive = true;
+ }
+ console.log("dragging", obj.elType, { interactionState, obj });
+ });
+ obj.on("down", function (_e) {
+ const e = _e as MouseEvent;
+ interactionState.pointerAtDown = [e.x, e.y];
+ console.log("down", obj.elType, { interactionState, obj });
+ });
+ obj.on("hit", function (_e) {
+ interactionState.dragActive = false;
+ console.log("hit", obj.elType, { interactionState, obj });
+ });
+ obj.on("up", function (_e) {
+ interactionState.dragActive = false;
+ console.log("up", obj.elType, { interactionState, obj });
+ });
+ obj.on("keyfocusout", function (_e) {
+ interactionState.dragActive = false;
+ console.log("keyfocusout", obj.elType, { interactionState, obj });
+ });
+ obj.on("keydown", function (_e) {
+ const e = _e as KeyboardEvent;
+ if (e.key === "Enter") {
+ interactionState.dragActive = false;
+ }
+ console.log("keydown", obj.elType, { interactionState, obj });
+ });
+}
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/li.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/li.tsx
new file mode 100644
index 000000000..489455dca
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/li.tsx
@@ -0,0 +1,17 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import type { LiProps } from "@doenet/doenetml-worker-rust";
+import { generateHtmlId } from "../utils";
+
+export const Li: BasicComponentWithPassthroughChildren<{
+ props: LiProps;
+}> = ({ children, node, annotation, ancestors }) => {
+ const htmlId = generateHtmlId(node, annotation, ancestors);
+ const label = node.data.props.label;
+ return (
+
+ {label}
+ {children}
+
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/line.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/line.tsx
new file mode 100644
index 000000000..481a6af4d
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/line.tsx
@@ -0,0 +1,127 @@
+import React from "react";
+import { BasicComponent } from "../types";
+import { GraphContext, LAYER_OFFSETS } from "./graph";
+import * as JSG from "jsxgraph";
+import { attachStandardGraphListeners } from "./jsxgraph/listeners";
+
+export const LineInGraph: BasicComponent = ({ node }) => {
+ const board = React.useContext(GraphContext);
+ const lineRef = React.useRef(null);
+
+ React.useEffect(() => {
+ if (!board) {
+ lineRef.current = null;
+ return;
+ }
+ if (lineRef.current) {
+ return;
+ }
+ const line = createLine(board, {
+ numericalPoints: [
+ [0, 0],
+ [1, 1],
+ ],
+ labelForGraph: "test",
+ lineColor: "var(--mainGreen)",
+ hidden: false,
+ fixed: false,
+ draggable: true,
+ fixLocation: false,
+ layer: 0,
+ selectedStyle: { lineStyle: "solid", lineOpacity: 1, lineWidth: 2 },
+ dashed: false,
+ });
+ lineRef.current = line;
+ if (!line) {
+ return;
+ }
+
+ attachStandardGraphListeners(line);
+
+ return () => {
+ line.off("drag");
+ line.off("down");
+ line.off("hit");
+ line.off("up");
+ line.off("keyfocusout");
+ line.off("keydown");
+ board.removeObject(line);
+ };
+ }, [board, lineRef]);
+
+ if (!board) {
+ return null;
+ }
+
+ return null;
+};
+
+function createLine(
+ board: JSG.Board,
+ props: {
+ numericalPoints: [[number, number], [number, number]];
+ labelForGraph: string;
+ lineColor: string;
+ hidden: boolean;
+ fixed: boolean;
+ draggable: boolean;
+ fixLocation: boolean;
+ layer: number;
+ selectedStyle: {
+ lineStyle: string;
+ lineOpacity: number;
+ lineWidth: number;
+ };
+ dashed: boolean;
+ },
+) {
+ if (
+ props.numericalPoints?.length !== 2 ||
+ props.numericalPoints.some((x) => x.length !== 2)
+ ) {
+ return null;
+ }
+
+ const lineColor = props.lineColor;
+
+ // Things to be passed to JSXGraph as attributes
+ const jsxLineAttributes: JSG.GeometryElementAttributes &
+ JSG.LineAttributes = {
+ name: props.labelForGraph,
+ visible: !props.hidden,
+ fixed: props.fixed,
+ layer: 10 * props.layer + LAYER_OFFSETS.line,
+ strokeColor: lineColor,
+ strokeOpacity: props.selectedStyle.lineOpacity,
+ highlightStrokeColor: lineColor,
+ highlightStrokeOpacity: props.selectedStyle.lineOpacity * 0.5,
+ strokeWidth: props.selectedStyle.lineWidth,
+ highlightStrokeWidth: props.selectedStyle.lineWidth,
+ dash: styleToDash(props.selectedStyle.lineStyle, props.dashed),
+ highlight: !props.fixLocation,
+ };
+
+ const through = [
+ [...props.numericalPoints[0]],
+ [...props.numericalPoints[1]],
+ ];
+
+ const line: JSG.Line = board.create("line", through, jsxLineAttributes);
+
+ return line;
+}
+
+/**
+ * Return the the dash length for a given style.
+ */
+function styleToDash(style: string, dash: boolean) {
+ if (style === "dashed" || dash) {
+ return 2;
+ } else if (style === "solid") {
+ return 0;
+ } else if (style === "dotted") {
+ return 1;
+ } else {
+ return 0;
+ }
+}
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/m.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/m.tsx
new file mode 100644
index 000000000..4db05ac1f
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/m.tsx
@@ -0,0 +1,18 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import { useAppSelector } from "../../state/hooks";
+import { renderingOnServerSelector } from "../../state/redux-slices/global";
+
+export const M: BasicComponentWithPassthroughChildren = ({ children }) => {
+ const onServer = useAppSelector(renderingOnServerSelector);
+ if (onServer) {
+ return {children};
+ }
+ // better-react-mathjax cannot handle multiple children (it will not update when they change)
+ // so create a single string.
+ const childrenString = Array.isArray(children)
+ ? children.join("")
+ : String(children);
+
+ return React.createElement("m", {}, childrenString);
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/math.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/math.tsx
new file mode 100644
index 000000000..fa4fecad8
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/math.tsx
@@ -0,0 +1,11 @@
+import React from "react";
+import { BasicComponent } from "../types";
+
+type MathData = { props: { latex: string } };
+
+export const Math: BasicComponent = ({ node }) => {
+ // better-react-mathjax cannot handle multiple children (it will not update when they change)
+ // so create a single string.
+ const latexString = node.data.props.latex;
+ return React.createElement("m", {}, latexString);
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/ol.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/ol.tsx
new file mode 100644
index 000000000..0d57d9cf0
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/ol.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import type { OlProps } from "@doenet/doenetml-worker-rust";
+
+export const Ol: BasicComponentWithPassthroughChildren<{
+ props: OlProps;
+}> = ({ children, node }) => {
+ return {children}
;
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/p.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/p.tsx
new file mode 100644
index 000000000..06f9f3b3c
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/p.tsx
@@ -0,0 +1,10 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import type { PProps } from "@doenet/doenetml-worker-rust";
+
+export const P: BasicComponentWithPassthroughChildren<{ props: PProps }> = ({
+ children,
+ node,
+}) => {
+ return {children}
;
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/point.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/point.tsx
new file mode 100644
index 000000000..2f7dc3ac8
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/point.tsx
@@ -0,0 +1,115 @@
+import React from "react";
+import { BasicComponent } from "../types";
+import { GraphContext, LAYER_OFFSETS } from "./graph";
+import * as JSG from "jsxgraph";
+import { attachStandardGraphListeners } from "./jsxgraph/listeners";
+
+export const PointInGraph: BasicComponent = ({ node }) => {
+ const board = React.useContext(GraphContext);
+ const pointRef = React.useRef(null);
+
+ React.useEffect(() => {
+ if (!board) {
+ pointRef.current = null;
+ return;
+ }
+ if (pointRef.current) {
+ return;
+ }
+ const point = createPoint(board, {
+ coords: [1, 1],
+ labelForGraph: "test",
+ lineColor: "var(--mainPurple)",
+ hidden: false,
+ fixed: false,
+ draggable: true,
+ fixLocation: false,
+ layer: 0,
+ selectedStyle: { lineStyle: "solid", lineOpacity: 1, lineWidth: 2 },
+ dashed: false,
+ });
+ pointRef.current = point;
+ if (!point) {
+ return;
+ }
+
+ attachStandardGraphListeners(point);
+
+ return () => {
+ point.off("drag");
+ point.off("down");
+ point.off("hit");
+ point.off("up");
+ point.off("keyfocusout");
+ point.off("keydown");
+ board.removeObject(point);
+ };
+ }, [board, pointRef]);
+
+ if (!board) {
+ return null;
+ }
+
+ return null;
+};
+
+function createPoint(
+ board: JSG.Board,
+ props: {
+ coords: [number, number];
+ labelForGraph: string;
+ lineColor: string;
+ hidden: boolean;
+ fixed: boolean;
+ draggable: boolean;
+ fixLocation: boolean;
+ layer: number;
+ selectedStyle: {
+ lineStyle: string;
+ lineOpacity: number;
+ lineWidth: number;
+ };
+ dashed: boolean;
+ },
+) {
+ const lineColor = props.lineColor;
+
+ // Things to be passed to JSXGraph as attributes
+ const jsxLineAttributes: JSG.PointAttributes = {
+ name: props.labelForGraph,
+ visible: !props.hidden,
+ fixed: props.fixed,
+ layer: 10 * props.layer + LAYER_OFFSETS.line,
+ strokeColor: lineColor,
+ strokeOpacity: props.selectedStyle.lineOpacity,
+ highlightStrokeColor: lineColor,
+ highlightStrokeOpacity: props.selectedStyle.lineOpacity * 0.5,
+ strokeWidth: props.selectedStyle.lineWidth,
+ highlightStrokeWidth: props.selectedStyle.lineWidth,
+ dash: styleToDash(props.selectedStyle.lineStyle, props.dashed),
+ highlight: !props.fixLocation,
+ };
+
+ const line: JSG.Point = board.create(
+ "point",
+ props.coords,
+ jsxLineAttributes,
+ );
+
+ return line;
+}
+
+/**
+ * Return the the dash length for a given style.
+ */
+function styleToDash(style: string, dash: boolean) {
+ if (style === "dashed" || dash) {
+ return 2;
+ } else if (style === "solid") {
+ return 0;
+ } else if (style === "dotted") {
+ return 1;
+ } else {
+ return 0;
+ }
+}
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/problem.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/problem.tsx
new file mode 100644
index 000000000..eb5335750
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/problem.tsx
@@ -0,0 +1,18 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import { Element } from "../element";
+
+export const Problem: BasicComponentWithPassthroughChildren<{
+ titleElmId?: number;
+}> = ({ children, node, visibilityRef }) => {
+ const titleElmId = node.data.titleElmId;
+
+ const title = titleElmId != null ? : "Problem";
+
+ return (
+
+
{title}
+ {children}
+
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/text-input.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/text-input.tsx
new file mode 100644
index 000000000..2fdc5b53c
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/text-input.tsx
@@ -0,0 +1,11 @@
+import React from "react";
+import type { TextInputProps } from "@doenet/doenetml-worker-rust";
+import { BasicComponent } from "../types";
+
+type TextInputData = { props: TextInputProps };
+
+export const TextInput: BasicComponent = ({ node }) => {
+ const value = node.data.props.immediateValue;
+
+ return {value};
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/text.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/text.tsx
new file mode 100644
index 000000000..543de0f5a
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/text.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { BasicComponent } from "../types";
+import type { TextProps } from "@doenet/doenetml-worker-rust";
+
+type TextData = { props: TextProps };
+
+export const Text: BasicComponent = ({ node }) => {
+ return {node.data.props.value};
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/title.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/title.tsx
new file mode 100644
index 000000000..f05ce04de
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/title.tsx
@@ -0,0 +1,8 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+
+export const Title: BasicComponentWithPassthroughChildren<{}> = ({
+ children,
+}) => {
+ return {children};
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/ul.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/ul.tsx
new file mode 100644
index 000000000..894683d0b
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/ul.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import type { UlProps } from "@doenet/doenetml-worker-rust";
+
+export const Ul: BasicComponentWithPassthroughChildren<{
+ props: UlProps;
+}> = ({ children, node }) => {
+ return ;
+};
diff --git a/packages/doenetml-prototype/src/renderers/pretext-xml/xref.tsx b/packages/doenetml-prototype/src/renderers/pretext-xml/xref.tsx
new file mode 100644
index 000000000..5993c2441
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/pretext-xml/xref.tsx
@@ -0,0 +1,16 @@
+import React from "react";
+import { BasicComponentWithPassthroughChildren } from "../types";
+import type { XrefProps } from "@doenet/doenetml-worker-rust";
+import { normalizeAttrs } from "../../utils/pretext/normalize-attrs";
+
+export const Xref: BasicComponentWithPassthroughChildren<{
+ props: XrefProps;
+}> = ({ children, node }) => {
+ const referentHtmlId = `doenet-id-${node.data.props.referent}`;
+
+ return React.createElement(
+ "xref",
+ normalizeAttrs({ ref: referentHtmlId }),
+ {children},
+ );
+};
diff --git a/packages/doenetml-prototype/src/renderers/renderers.ts b/packages/doenetml-prototype/src/renderers/renderers.ts
new file mode 100644
index 000000000..0fef4577b
--- /dev/null
+++ b/packages/doenetml-prototype/src/renderers/renderers.ts
@@ -0,0 +1,158 @@
+import { BasicComponent, BasicComponentWithPassthroughChildren } from "./types";
+import {
+ Answer,
+ Document,
+ Graph,
+ LineInGraph,
+ M,
+ Math,
+ P,
+ PointInGraph,
+ Problem,
+ Division,
+ Text,
+ TextInput,
+ Boolean,
+ Title,
+ _Fragment,
+ Xref,
+ Ol,
+ Li,
+ Ul,
+ ChoiceInput,
+} from "./doenet";
+import * as PretextComponent from "./pretext-xml";
+
+export type CommonProps = {
+ monitorVisibility?: boolean;
+};
+export type Component = {
+ // At this point, we don't care about the type of the data prop
+ // The component author should make sure it's correct.
+ // TODO: Can we make this a union of all possible data props?
+ component: BasicComponent;
+ passthroughChildren?: false;
+} & CommonProps;
+export type ComponentWithPassthroughChildren = {
+ component: BasicComponentWithPassthroughChildren;
+ passthroughChildren: true;
+} & CommonProps;
+
+export type RendererObject = Record<
+ string | symbol,
+ Component | ComponentWithPassthroughChildren
+>;
+
+/**
+ * A key used to identify the fallback renderer in the renderer object.
+ * If a renderer is present with this key, it will be used in the case where no
+ * specific renderer is found for a given tag name.
+ */
+export const FALLBACK_RENDERER_KEY = Symbol("fallback");
+
+/**
+ * A map of tag names to components. This is used for naive component rendering, where the
+ * tag name uniquely determines the component to render.
+ */
+export const TEXT_MODE_COMPONENTS: RendererObject = {
+ answer: { component: Answer },
+ choiceInput: { component: ChoiceInput },
+ p: { component: P, passthroughChildren: true },
+ document: { component: Document, passthroughChildren: true },
+ m: { component: M, passthroughChildren: true },
+ math: { component: Math },
+ graph: { component: Graph },
+ division: {
+ component: Division,
+ passthroughChildren: true,
+ monitorVisibility: true,
+ },
+ problem: {
+ component: Problem,
+ passthroughChildren: true,
+ monitorVisibility: true,
+ },
+ textInput: { component: TextInput },
+ text: { component: Text },
+ boolean: { component: Boolean },
+ title: { component: Title, passthroughChildren: true },
+ _fragment: { component: _Fragment, passthroughChildren: true },
+ xref: { component: Xref, passthroughChildren: true },
+ ol: { component: Ol, passthroughChildren: true },
+ ul: { component: Ul, passthroughChildren: true },
+ li: { component: Li, passthroughChildren: true },
+
+ // For PreTeXt compatibility
+ pretext: { component: _Fragment, passthroughChildren: true },
+ article: { component: _Fragment, passthroughChildren: true },
+ book: { component: _Fragment, passthroughChildren: true },
+};
+
+export const GRAPH_MODE_COMPONENTS: RendererObject = {
+ line: { component: LineInGraph },
+ point: { component: PointInGraph },
+};
+
+/**
+ * A map of tag names to components. This is used for naive component rendering, where the
+ * tag name uniquely determines the component to render.
+ */
+export const PRETEXT_TEXT_MODE_COMPONENTS: RendererObject = {
+ answer: { component: PretextComponent.Answer },
+ choiceInput: { component: PretextComponent.ChoiceInput },
+ p: { component: PretextComponent.P, passthroughChildren: true },
+ document: {
+ component: PretextComponent._PassThroughWithTag,
+ passthroughChildren: true,
+ },
+ m: { component: PretextComponent.M, passthroughChildren: true },
+ math: { component: PretextComponent.Math },
+ graph: { component: PretextComponent.Graph },
+ division: {
+ component: PretextComponent.Division,
+ passthroughChildren: true,
+ monitorVisibility: true,
+ },
+ problem: {
+ component: PretextComponent.Problem,
+ passthroughChildren: true,
+ monitorVisibility: true,
+ },
+ textInput: { component: PretextComponent.TextInput },
+ text: { component: PretextComponent.Text },
+ boolean: { component: PretextComponent.Boolean },
+ title: { component: PretextComponent.Title, passthroughChildren: true },
+ _fragment: {
+ component: PretextComponent._Fragment,
+ passthroughChildren: true,
+ },
+ xref: { component: PretextComponent.Xref, passthroughChildren: true },
+ ol: { component: PretextComponent.Ol, passthroughChildren: true },
+ ul: { component: PretextComponent.Ul, passthroughChildren: true },
+ li: { component: PretextComponent.Li, passthroughChildren: true },
+
+ // For PreTeXt compatibility
+ pretext: {
+ component: PretextComponent._PassThroughWithTagAndNewline,
+ passthroughChildren: true,
+ },
+ article: {
+ component: PretextComponent._PassThroughWithTagAndNewline,
+ passthroughChildren: true,
+ },
+ book: {
+ component: PretextComponent._PassThroughWithTagAndNewline,
+ passthroughChildren: true,
+ },
+ // Provide a renderer for unrecognized elements. This allows us to support
+ // pretext tags we don't currently know about.
+ [FALLBACK_RENDERER_KEY]: {
+ component: PretextComponent._PassThroughWithTag,
+ passthroughChildren: true,
+ },
+};
+
+export const PRETEXT_GRAPH_MODE_COMPONENTS: RendererObject = {
+ line: { component: PretextComponent.LineInGraph },
+ point: { component: PretextComponent.PointInGraph },
+};
diff --git a/packages/doenetml-prototype/src/state/redux-slices/dast/slice.ts b/packages/doenetml-prototype/src/state/redux-slices/dast/slice.ts
index 9ba2a7837..5ee959e8d 100644
--- a/packages/doenetml-prototype/src/state/redux-slices/dast/slice.ts
+++ b/packages/doenetml-prototype/src/state/redux-slices/dast/slice.ts
@@ -114,6 +114,12 @@ export const dastReducer = dastSlice.reducer;
export const _dastReducerActions = { ...dastSlice.actions };
const selfSelector = (state: RootState) => state.dast;
+export const dastSelector = (state: RootState) =>
+ selfSelector(state).dastFromSource;
+export const flatDastSelector = (state: RootState) =>
+ selfSelector(state).flatDastRoot;
+export const doenetSourceSelector = (state: RootState) =>
+ selfSelector(state).source;
export const errorsSelector = (state: RootState) =>
selfSelector(state).dastErrors;
diff --git a/packages/doenetml-prototype/src/state/redux-slices/global/slice.ts b/packages/doenetml-prototype/src/state/redux-slices/global/slice.ts
index 47a834168..4f59b521e 100644
--- a/packages/doenetml-prototype/src/state/redux-slices/global/slice.ts
+++ b/packages/doenetml-prototype/src/state/redux-slices/global/slice.ts
@@ -10,12 +10,17 @@ export interface GlobalState {
* Whether dark mode is the preferred theme.
*/
darkMode: boolean;
+ /**
+ * Whether components should be rendered in Doenet mode (interactive webpage) or PreTeXt mode (static XML for export).
+ */
+ renderMode: "doenet" | "pretext";
}
// Define the initial state using that type
const initialState: GlobalState = {
renderingOnServer: typeof process !== "undefined" && !process?.env?.browser,
darkMode: false,
+ renderMode: "doenet",
};
const dastSlice = createSlice({
@@ -25,6 +30,12 @@ const dastSlice = createSlice({
_setDarkMode: (state, action: PayloadAction) => {
state.darkMode = action.payload;
},
+ _setRenderMode: (
+ state,
+ action: PayloadAction,
+ ) => {
+ state.renderMode = action.payload;
+ },
},
});
@@ -38,3 +49,5 @@ export const _globalReducerActions = { ...dastSlice.actions };
const selfSelector = (state: RootState) => state.global;
export const renderingOnServerSelector = (state: RootState) =>
selfSelector(state).renderingOnServer;
+export const renderModeSelector = (state: RootState) =>
+ selfSelector(state).renderMode;
diff --git a/packages/doenetml-prototype/src/utils/pretext/ensure-pretext-tag.ts b/packages/doenetml-prototype/src/utils/pretext/ensure-pretext-tag.ts
new file mode 100644
index 000000000..e7ee6751e
--- /dev/null
+++ b/packages/doenetml-prototype/src/utils/pretext/ensure-pretext-tag.ts
@@ -0,0 +1,84 @@
+import type {
+ AnnotatedElementRef,
+ FlatDastRoot,
+ FlatDastElement,
+} from "@doenet/doenetml-worker-rust";
+
+/**
+ * Mutate `flatDast` to ensure that the root tag is a `` tag with a division tag immediately inside
+ * (either a `` or a ``).
+ */
+export function ensurePretextTag(
+ flatDast: FlatDastRoot,
+ ensuredDivisionType: "article" | "book" = "article",
+) {
+ const elements = flatDast.elements;
+ // The root of the document is probably a `` tag. If it is, remove it.
+ if (flatDast.children.length === 1) {
+ const firstChild = flatDast.children[0];
+ if (
+ isAnnotatedElementRef(firstChild) &&
+ elements[firstChild.id].name === "document"
+ ) {
+ flatDast.children = elements[firstChild.id].children;
+ }
+ }
+
+ let pretextElement = flatDast.children
+ .map((r) => (isAnnotatedElementRef(r) ? elements[r.id] : null))
+ .find((r) => r?.name === "pretext");
+ if (!pretextElement) {
+ const id = elements.length;
+ pretextElement = {
+ type: "element",
+ name: "pretext",
+ children: flatDast.children,
+ attributes: {},
+ data: { id },
+ } as FlatDastElement;
+ elements.push(pretextElement);
+ flatDast.children = [{ id, annotation: "original" }];
+ }
+
+ if (!pretextElement.children) {
+ console.log(pretextElement);
+ }
+ // Ensure that a or tag is immediately inside the tag
+ // There may be a tag that is a sibling of the division tag.
+ const hasDivisionTag = pretextElement.children.find(
+ (r) =>
+ isAnnotatedElementRef(r) &&
+ (elements[r.id].name === "book" ||
+ elements[r.id].name === "article"),
+ );
+ if (!hasDivisionTag) {
+ const docinfoElementPos = pretextElement.children.findIndex(
+ (r) =>
+ isAnnotatedElementRef(r) && elements[r.id].name === "docinfo",
+ );
+ const siblings = pretextElement.children.slice(
+ 0,
+ docinfoElementPos + 1,
+ );
+ const children = pretextElement.children.slice(docinfoElementPos + 1);
+
+ const divisionElement = {
+ type: "element",
+ name: ensuredDivisionType,
+ children,
+ attributes: {},
+ data: { id: elements.length },
+ } as FlatDastElement;
+ elements.push(divisionElement);
+
+ pretextElement.children = siblings;
+ pretextElement.children.push({
+ id: divisionElement.data.id,
+ annotation: "original",
+ });
+ }
+}
+
+function isAnnotatedElementRef(node: any): node is AnnotatedElementRef {
+ return node?.id != null && node?.type == null;
+}
diff --git a/packages/doenetml-prototype/src/utils/pretext/normalize-attrs.ts b/packages/doenetml-prototype/src/utils/pretext/normalize-attrs.ts
new file mode 100644
index 000000000..80bc8c9db
--- /dev/null
+++ b/packages/doenetml-prototype/src/utils/pretext/normalize-attrs.ts
@@ -0,0 +1,39 @@
+const SPECIAL_PROP_NAMES = new Set([
+ "key",
+ "ref",
+ "__self",
+ "__source",
+ "children",
+]);
+
+/**
+ * Adjust an attribute object to make sure no attribute names collide with special React attributes.
+ * Any such collisions are prefixed with `pretext:` (which will be stripped away during printing).
+ * For example `ref` becomes `pretext:ref`.
+ */
+export function normalizeAttrs>(attrs: T): T {
+ return Object.fromEntries(
+ Object.entries(attrs).map(([key, value]) => {
+ if (SPECIAL_PROP_NAMES.has(key)) {
+ return [`pretext:${key}`, value];
+ }
+ return [key, value];
+ }),
+ ) as T;
+}
+
+/**
+ * Removes `pretext:` prefixes from attribute names.
+ */
+export function denormalizeAttrs>(
+ attrs: T,
+): T {
+ return Object.fromEntries(
+ Object.entries(attrs).map(([key, value]) => {
+ if (key.startsWith("pretext:")) {
+ return [key.slice(8), value];
+ }
+ return [key, value];
+ }),
+ ) as T;
+}
diff --git a/packages/doenetml-prototype/src/utils/pretext/render-to-pretext.tsx b/packages/doenetml-prototype/src/utils/pretext/render-to-pretext.tsx
new file mode 100644
index 000000000..89182e109
--- /dev/null
+++ b/packages/doenetml-prototype/src/utils/pretext/render-to-pretext.tsx
@@ -0,0 +1,76 @@
+import React from "react";
+import {
+ _dastReducerActions,
+ dastReducer,
+} from "../../state/redux-slices/dast";
+import { toXml } from "xast-util-to-xml";
+import { FlatDastRoot } from "../../../../doenetml-worker-rust/dist/CoreWorker";
+import { configureStore } from "@reduxjs/toolkit";
+import {
+ _globalReducerActions,
+ globalReducer,
+} from "../../state/redux-slices/global";
+import { Provider } from "react-redux";
+import { Element } from "../../renderers";
+import { ensurePretextTag } from "./ensure-pretext-tag";
+import { renderReactToXast } from "./xast-reconciler";
+import { normalizeAttrs } from "./normalize-attrs";
+
+/**
+ * Use React's rendering pipeline to render the FlatDast to PreTeXt.
+ */
+export function renderToPretext(flatDast: FlatDastRoot) {
+ // Do some pre-processing on the root
+ flatDast = structuredClone(flatDast);
+ ensurePretextTag(flatDast);
+
+ // Make sure none of the attribute names clash with special React names (e.g. `ref` and `key`).
+ for (const element of flatDast.elements) {
+ element.attributes = normalizeAttrs(element.attributes);
+ }
+
+ // Create a new store independent of the existing Redux store.
+ // We will configure it separately
+ const store = configureStore({
+ reducer: {
+ dast: dastReducer,
+ global: globalReducer,
+ },
+ });
+
+ // Strip off any `name` attribute left over from the DAST
+ for (const element of flatDast.elements) {
+ delete element.attributes.name;
+ }
+
+ store.dispatch(_dastReducerActions._setFlatDastRoot(flatDast));
+ store.dispatch(_globalReducerActions._setRenderMode("pretext"));
+
+ const xast = renderReactToXast(
+
+ {flatDast.children.map((child) => {
+ if (typeof child === "string") {
+ return child;
+ }
+ return (
+
+ );
+ })}
+ ,
+ );
+
+ // Make sure we include an `` instruction on the first line
+ xast.children.unshift({ type: "text", value: "\n" });
+ xast.children.unshift({
+ type: "instruction",
+ name: "xml",
+ value: 'version="1.0" encoding="UTF-8"',
+ });
+
+ return toXml(xast, { closeEmptyElements: true });
+}
diff --git a/packages/doenetml-prototype/src/utils/pretext/xast-reconciler.ts b/packages/doenetml-prototype/src/utils/pretext/xast-reconciler.ts
new file mode 100644
index 000000000..4411c7f37
--- /dev/null
+++ b/packages/doenetml-prototype/src/utils/pretext/xast-reconciler.ts
@@ -0,0 +1,194 @@
+import React from "react";
+import reconciler, * as ReactReconciler from "react-reconciler";
+import { DefaultEventPriority } from "react-reconciler/constants";
+import type * as Xast from "xast";
+import type { DastAttribute } from "@doenet/doenetml-worker-rust";
+import { denormalizeAttrs } from "./normalize-attrs";
+
+type RootContainer = Xast.Root & {
+ _rootContainer?: ReactReconciler.FiberRoot;
+};
+
+type Type = string;
+
+type Props = {
+ children?: unknown[];
+ [key: string]: any;
+};
+
+type Instance = Xast.Element;
+
+type TextInstance = Xast.Text;
+
+function isDastAttribute(node: any): node is DastAttribute {
+ return node && node.type === "attribute";
+}
+
+/**
+ * The config object used by `react-reconciler` to render React elements to Xast.
+ */
+const HOST_CONFIG: ReactReconciler.HostConfig<
+ Type,
+ Props,
+ RootContainer,
+ Instance,
+ TextInstance,
+ unknown,
+ unknown,
+ unknown,
+ unknown,
+ unknown,
+ unknown,
+ unknown,
+ unknown
+> = {
+ isPrimaryRenderer: true,
+ supportsMutation: true,
+ supportsPersistence: false,
+ supportsHydration: false,
+ noTimeout: -1,
+
+ // Define other methods as needed
+ createInstance(
+ elmName,
+ props,
+ rootContainerInstance,
+ hostContext,
+ internalInstanceHandle,
+ ) {
+ const { children, ...rest } = props;
+ const attributes = Object.fromEntries(
+ Object.entries(denormalizeAttrs(rest)).map(([key, value]) => {
+ if (typeof value === "string") {
+ return [key, value];
+ }
+ if (isDastAttribute(value)) {
+ // XXX: Check whether this is the correct behavior
+ // For now, we filter out any non-text children
+ const val = value.children
+ .map((x) => (x.type === "text" ? x.value : ""))
+ .join("");
+ return [key, val];
+ }
+ return [key, value];
+ }),
+ );
+ return {
+ type: "element",
+ name: elmName,
+ attributes,
+ children: [],
+ };
+ },
+
+ createTextInstance(
+ text,
+ rootContainerInstance,
+ hostContext,
+ internalInstanceHandle,
+ ): TextInstance {
+ return { type: "text", value: text };
+ },
+
+ appendInitialChild(parentInstance, child) {
+ parentInstance.children.push(child);
+ },
+ appendChild(parentInstance, child) {
+ parentInstance.children.push(child);
+ },
+ appendChildToContainer(container, child) {
+ container.children.push(child);
+ },
+ clearContainer(container) {
+ container.children.length = 0;
+ },
+
+ finalizeInitialChildren(
+ instance,
+ type,
+ props,
+ rootContainerInstance,
+ hostContext,
+ ) {
+ return false;
+ },
+
+ prepareUpdate(
+ instance,
+ type,
+ oldProps,
+ newProps,
+ rootContainerInstance,
+ hostContext,
+ ) {
+ return null;
+ },
+
+ commitUpdate(
+ instance,
+ updatePayload,
+ type,
+ oldProps,
+ newProps,
+ internalInstanceHandle,
+ ) {},
+
+ commitTextUpdate(textInstance, oldText, newText) {
+ textInstance.value = newText;
+ },
+ shouldSetTextContent(type, props) {
+ return false;
+ },
+ getRootHostContext(rootContainerInstance) {},
+ getChildHostContext(parentHostContext, type, rootContainerInstance) {
+ return parentHostContext;
+ },
+ prepareForCommit(containerInfo) {
+ return null;
+ },
+ resetAfterCommit(containerInfo) {},
+ afterActiveInstanceBlur() {},
+ beforeActiveInstanceBlur() {},
+ cancelTimeout(id) {},
+ detachDeletedInstance(node) {},
+ getCurrentEventPriority() {
+ return DefaultEventPriority;
+ },
+ getInstanceFromNode(node) {
+ return null;
+ },
+ getInstanceFromScope(scopeInstance) {
+ return null;
+ },
+ getPublicInstance(instance) {
+ return instance;
+ },
+ preparePortalMount(containerInfo) {
+ return null;
+ },
+ prepareScopeUpdate(scopeInstance, instance) {},
+ scheduleTimeout(fn, delay) {},
+};
+
+const renderer = reconciler(HOST_CONFIG);
+
+/**
+ * Render a React element to a Xast Abstract Syntax Tree.
+ */
+export function renderReactToXast(element: React.ReactNode): Xast.Root {
+ const xastRoot: Xast.Root = { type: "root", children: [] };
+ const container = renderer.createContainer(
+ xastRoot,
+ 0,
+ null,
+ false,
+ null,
+ "xastRoot",
+ console.log,
+ null,
+ );
+
+ renderer.updateContainer(element, container);
+
+ return xastRoot;
+}
diff --git a/packages/doenetml-prototype/test/pretext-export.test.ts b/packages/doenetml-prototype/test/pretext-export.test.ts
new file mode 100644
index 000000000..0f632a0de
--- /dev/null
+++ b/packages/doenetml-prototype/test/pretext-export.test.ts
@@ -0,0 +1,226 @@
+import { describe, expect, it, afterAll } from "vitest";
+import util from "util";
+import { lezerToDast, toXml } from "@doenet/parser";
+import { normalizeDocumentDast } from "../src/state/redux-slices/dast/utils/normalize-dast";
+import { ensurePretextTag } from "../src/utils/pretext/ensure-pretext-tag";
+import { FlatDastRoot } from "@doenet/doenetml-worker-rust";
+import { renderToPretext } from "../src/utils/pretext/render-to-pretext";
+import { RunThroughCore } from "./utils/run-through-core";
+
+const origLog = console.log;
+console.log = (...args) => {
+ origLog(...args.map((x) => util.inspect(x, false, 10, true)));
+};
+
+//
+// Hi
+//
+const SIMPLE_FLAT_DAST = {
+ type: "root",
+ children: [
+ {
+ id: 0,
+ annotation: "original",
+ },
+ ],
+ elements: [
+ {
+ type: "element",
+ name: "document",
+ attributes: {},
+ children: [
+ {
+ id: 1,
+ annotation: "original",
+ },
+ ],
+ data: {
+ id: 0,
+ action_names: [],
+ props: {},
+ },
+ },
+ {
+ type: "element",
+ name: "p",
+ attributes: {},
+ children: ["\n Hi\n"],
+ data: {
+ id: 1,
+ action_names: [],
+ },
+ },
+ ],
+ warnings: [],
+} as FlatDastRoot;
+
+const coreRunner = new RunThroughCore();
+
+afterAll(async () => {
+ await coreRunner.close();
+});
+
+describe("Pretext export", async () => {
+ it("Can process doenet code run through core", async () => {
+ await coreRunner.processToFatDast(`hello world
`);
+ });
+ it("Wraps root in tag", () => {
+ const flatDast = structuredClone(SIMPLE_FLAT_DAST);
+ expect(renderToPretext(flatDast)).toMatchInlineSnapshot(`
+ "
+
+
+
+ Hi
+
+
+ "
+ `);
+ });
+ it("passes through attributes", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ How about
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(
+ `
+ "
+
+
+ How about
+
+ "
+ `,
+ );
+ });
+ it("expands to pretext element", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+
+ How about $mi?
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ foo
+ How about foo?
+
+ "
+ `);
+ });
+ it("expands to pretext element", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+
+ Foo
+ How about foo?
+
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+
+ Foo
+
+ How about foo?
+
+
+ "
+ `);
+ });
+ it("passes through unknown elements", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ Hi
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ Hi
+
+ "
+ `);
+ });
+ it("passes through attributes that conflict with special React prop names", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ Hi
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ Hi
+
+ "
+ `);
+ });
+ it("preserved existing or or tags", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ Hi
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ Hi
+
+ "
+ `);
+ });
+ it("preserved existing or or tags 2", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ Hi Z
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ Hi
+ Z
+ "
+ `);
+ });
+ it(" is not included in the auto-inserted division", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ Hi
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+ Hi
+
+
+ "
+ `);
+ });
+ it("name attribute is removed but pretext:name is not", async () => {
+ const flatDast = await coreRunner.processToFatDast(`
+ hi
there
+ `);
+
+ const pretext = renderToPretext(flatDast);
+ expect(pretext).toMatchInlineSnapshot(`
+ "
+
+
+ hi
there
+
+ "
+ `);
+ });
+});
diff --git a/packages/doenetml-prototype/test/react-to-xast.test.tsx b/packages/doenetml-prototype/test/react-to-xast.test.tsx
new file mode 100644
index 000000000..dea3bfc47
--- /dev/null
+++ b/packages/doenetml-prototype/test/react-to-xast.test.tsx
@@ -0,0 +1,32 @@
+import React from "react";
+import { describe, expect, it } from "vitest";
+import util from "util";
+import { renderReactToXast } from "../src/utils/pretext/xast-reconciler";
+
+const origLog = console.log;
+console.log = (...args) => {
+ origLog(...args.map((x) => util.inspect(x, false, 10, true)));
+};
+
+describe("react-to-xast", async () => {
+ it("can convert a simple react element to xast", () => {
+ expect(renderReactToXast(Hi
)).toMatchInlineSnapshot(`
+ {
+ "children": [
+ {
+ "attributes": {},
+ "children": [
+ {
+ "type": "text",
+ "value": "Hi",
+ },
+ ],
+ "name": "p",
+ "type": "element",
+ },
+ ],
+ "type": "root",
+ }
+ `);
+ });
+});
diff --git a/packages/doenetml-prototype/test/tsconfig.json b/packages/doenetml-prototype/test/tsconfig.json
index 351e041b9..31607ed97 100644
--- a/packages/doenetml-prototype/test/tsconfig.json
+++ b/packages/doenetml-prototype/test/tsconfig.json
@@ -1,4 +1,10 @@
{
"extends": "../../../tsconfig.test.json",
- "include": ["**/*.test.*ts", "../src/**/*.ts", "../src/**/*.tsx"]
+ "include": [
+ "**/*.test.*ts",
+ "../src/**/*.ts",
+ "../src/**/*.tsx",
+ "./**/*.ts",
+ "react-to-xast.test.tsx"
+ ]
}
diff --git a/packages/doenetml-prototype/test/utils/dast-to-flat-dast.ts b/packages/doenetml-prototype/test/utils/dast-to-flat-dast.ts
new file mode 100644
index 000000000..2cf8e53ab
--- /dev/null
+++ b/packages/doenetml-prototype/test/utils/dast-to-flat-dast.ts
@@ -0,0 +1,64 @@
+import { lezerToDast, filterPositionInfo } from "@doenet/parser";
+import { normalizeDocumentDast } from "../../src/state/redux-slices/dast/utils/normalize-dast";
+import type { CoreWorker, FlatDastRoot } from "@doenet/doenetml-worker-rust";
+import * as Comlink from "comlink";
+import { doenetGlobalConfig } from "../../src/global-config";
+
+// @ts-ignore
+import workerSource from "@doenet/doenetml-worker-rust/index.js?raw";
+
+// We make a blob URL directly from the source code of the worker. This way we don't
+// need to load any other files
+const workerBlobUrl = URL.createObjectURL(
+ new Blob([workerSource], { type: "application/javascript" }),
+);
+doenetGlobalConfig.doenetWorkerUrl = workerBlobUrl;
+
+/**
+ * Create a DoenetCoreWorker that is wrapped in Comlink for a nice async API.
+ */
+export function createWrappedCoreWorker() {
+ const worker = new Worker(doenetGlobalConfig.doenetWorkerUrl, {
+ type: "classic",
+ });
+ return Comlink.wrap(worker) as Comlink.Remote;
+}
+
+/**
+ * Convert a string to normalized DAST
+ */
+export function toDast(source: string) {
+ return normalizeDocumentDast(lezerToDast(source));
+}
+
+/**
+ * Filter out position information from FlatDast
+ */
+function flatDastFilterPositionInfo(flatDast: FlatDastRoot): FlatDastRoot {
+ return filterPositionInfo(flatDast as any) as any as FlatDastRoot;
+}
+
+/**
+ * Create a worker initialized with empty flags and the source `source`.
+ */
+async function workerWithSource(source: string) {
+ const worker = createWrappedCoreWorker();
+ await worker.setFlags({ flags: {} });
+ await worker.setSource({
+ source,
+ dast: toDast(source),
+ });
+ return worker;
+}
+
+/**
+ * Script to be called by `webdriverio` to get the flat DAST.
+ */
+async function getFlatDast(source: string) {
+ const worker = await workerWithSource(source);
+
+ const flatDast = flatDastFilterPositionInfo(await worker.returnDast());
+ return flatDast;
+}
+
+(globalThis as any).getFlatDast = getFlatDast;
diff --git a/packages/doenetml-prototype/test/utils/run-through-core.ts b/packages/doenetml-prototype/test/utils/run-through-core.ts
new file mode 100644
index 000000000..ad15de48c
--- /dev/null
+++ b/packages/doenetml-prototype/test/utils/run-through-core.ts
@@ -0,0 +1,89 @@
+/** fd
+ * This file exports an object that can be used in tests. It spawns a headless browser and
+ * and loads the doenet core worker into that browser.
+ */
+import { remote } from "webdriverio";
+import type { FlatDastRoot } from "../../../doenetml-worker-rust/dist";
+// @ts-ignore
+import convertScript from "./dist/dast-to-flat-dast/index.js?raw";
+
+/**
+ * A processor that allows calls to be made to core via a headless browser.
+ */
+export class RunThroughCore {
+ browser?: WebdriverIO.Browser = undefined;
+ initRunning = false;
+ initRunningPromise = Promise.resolve();
+ initRunningPromiseResolve: (value: void) => void = () => {};
+ constructor() {
+ this._initPromise();
+ this.init();
+ }
+ _initPromise() {
+ let resolve: (value: void) => void = () => {};
+ this.initRunningPromise = new Promise((r) => {
+ resolve = r;
+ });
+ this.initRunningPromiseResolve = resolve;
+ }
+ async init() {
+ if (this.initRunning) {
+ return;
+ }
+ this.initRunning = true;
+ try {
+ // Initialize the browser
+ this.browser = await remote({
+ capabilities: {
+ browserName: "chrome",
+ "goog:chromeOptions": {
+ args: ["headless", "disable-gpu"],
+ },
+ },
+ logLevel: "error",
+ });
+ // Load in the web worker script
+ await this.browser.execute((scriptContent) => {
+ const scriptElement = document.createElement("script");
+ scriptElement.type = "module";
+ scriptElement.textContent = scriptContent;
+ document.head.appendChild(scriptElement);
+ }, convertScript);
+ } catch (e) {
+ throw e;
+ } finally {
+ this.initRunning = false;
+ this.initRunningPromiseResolve();
+ }
+ }
+ async close() {
+ if (this.browser) {
+ await this.browser.deleteSession();
+ this.browser = undefined;
+ this._initPromise();
+ }
+ }
+ async processToFatDast(input: string): Promise {
+ if (!this.browser) {
+ await this.init();
+ }
+ await this.initRunningPromise;
+ if (!this.browser) {
+ throw new Error("Failed to initialize browser");
+ }
+ const result = await this.browser.executeAsync(async (source, done) => {
+ window.setTimeout(() => {
+ done("" + new Error("Took too long to execute script"));
+ }, 5000);
+ try {
+ // @ts-ignore
+ const dast = await getFlatDast(source);
+ done(dast);
+ } catch (e) {
+ done("" + e);
+ }
+ }, input);
+
+ return result as FlatDastRoot;
+ }
+}
diff --git a/packages/doenetml-prototype/test/utils/run.ts b/packages/doenetml-prototype/test/utils/run.ts
new file mode 100644
index 000000000..6fb2ac8ea
--- /dev/null
+++ b/packages/doenetml-prototype/test/utils/run.ts
@@ -0,0 +1,68 @@
+/**
+ * This file (compiles to a file that) can be executed by node. It spawns a headless browser with core loaded in.
+ * You can then ask core to do certain processing tasks and get the result back.
+ */
+import fs from "node:fs";
+import yargs from "yargs";
+import { remote } from "webdriverio";
+// @ts-ignore
+import convertScript from "./dist/dast-to-flat-dast/index.js?raw";
+
+// Parse command-line arguments with yargs
+const argv = yargs(process.argv.slice(2))
+ .usage(`Usage: $0 -i 'My DoenetML'`)
+ .option("input", {
+ alias: "i",
+ description: "Input for toDast function",
+ type: "string",
+ })
+ .option("fileInput", {
+ alias: "f",
+ description: "Read input from a file",
+ type: "string",
+ })
+ .option("strip-position", {
+ description: "Strip position data from the DAST tree",
+ type: "boolean",
+ }).argv;
+
+if (argv.input == null && argv.fileInput == null) {
+ throw new Error("Must provide an input via -i or -f");
+}
+const input: string = argv.input ?? fs.readFileSync(argv.fileInput, "utf8");
+
+// Do the actual processing
+// We run web worker in the browser via webdriverio so that we get full compatibility
+(async () => {
+ const browser = await remote({
+ capabilities: {
+ browserName: "chrome",
+ "goog:chromeOptions": {
+ args: ["headless", "disable-gpu"],
+ },
+ },
+ logLevel: "error",
+ });
+ await browser.execute((scriptContent) => {
+ const scriptElement = document.createElement("script");
+ scriptElement.type = "module";
+ scriptElement.textContent = scriptContent;
+ document.head.appendChild(scriptElement);
+ }, convertScript);
+ const result = await browser.executeAsync(async (source, done) => {
+ window.setTimeout(() => {
+ done("" + new Error("Took too long to execute script"));
+ }, 5000);
+ try {
+ // @ts-ignore
+ const dast = await getFlatDast(source);
+ done(dast);
+ } catch (e) {
+ done("" + e);
+ }
+ }, input);
+
+ await browser.deleteSession();
+
+ console.log(JSON.stringify(result));
+})();
diff --git a/packages/doenetml-prototype/test/utils/vite.dast-to-flat-dast.config.ts b/packages/doenetml-prototype/test/utils/vite.dast-to-flat-dast.config.ts
new file mode 100644
index 000000000..7be98a7d9
--- /dev/null
+++ b/packages/doenetml-prototype/test/utils/vite.dast-to-flat-dast.config.ts
@@ -0,0 +1,23 @@
+import { defineConfig } from "vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+ base: "./",
+ plugins: [],
+ build: {
+ outDir: "./dist/dast-to-flat-dast/",
+ minify: false,
+ sourcemap: true,
+ lib: {
+ entry: {
+ index: "./dast-to-flat-dast.ts",
+ },
+ formats: ["es"],
+ },
+ rollupOptions: {
+ // If we do `external: ["yargs"]` then we do not produce a portable JS file,
+ // so only exclude node built-in modules
+ external: ["fs", "path", "node:fs"],
+ },
+ },
+});
diff --git a/packages/doenetml-prototype/test/utils/vite.run.config.ts b/packages/doenetml-prototype/test/utils/vite.run.config.ts
new file mode 100644
index 000000000..9b7969f9b
--- /dev/null
+++ b/packages/doenetml-prototype/test/utils/vite.run.config.ts
@@ -0,0 +1,24 @@
+import { defineConfig } from "vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+ base: "./",
+ plugins: [],
+ build: {
+ outDir: "./dist/run/",
+ emptyOutDir: false,
+ minify: false,
+ sourcemap: true,
+ lib: {
+ entry: {
+ index: "./run.ts",
+ },
+ formats: ["es"],
+ },
+ rollupOptions: {
+ // If we do `external: ["yargs"]` then we do not produce a portable JS file,
+ // so only exclude node built-in modules
+ external: ["fs", "path", "node:fs", "yargs", "webdriverio"],
+ },
+ },
+});
diff --git a/packages/doenetml-prototype/test/wasm-tests.test.browser.ts b/packages/doenetml-prototype/test/wasm-tests.test.browser.ts
index bdff39b79..17adc9f21 100644
--- a/packages/doenetml-prototype/test/wasm-tests.test.browser.ts
+++ b/packages/doenetml-prototype/test/wasm-tests.test.browser.ts
@@ -77,4 +77,24 @@ describe("wasm tests", () => {
});
}
});
+
+ it("can set the source of a worker multiple times", async () => {
+ let source: string;
+ const worker = createWrappedCoreWorker();
+ await worker.setFlags({ flags: {} });
+
+ source = "test
";
+ await worker.setSource({
+ source,
+ dast: toDast(source),
+ });
+ await worker.returnDast();
+
+ source = "";
+ await worker.setSource({
+ source,
+ dast: toDast(source),
+ });
+ await worker.returnDast();
+ });
});
diff --git a/packages/doenetml-prototype/vite.config.ts b/packages/doenetml-prototype/vite.config.ts
index b2634b8ae..107bd2725 100644
--- a/packages/doenetml-prototype/vite.config.ts
+++ b/packages/doenetml-prototype/vite.config.ts
@@ -3,8 +3,9 @@ import { PluginOption, defineConfig } from "vite";
import { viteStaticCopy, TransformOption } from "vite-plugin-static-copy";
import dts from "vite-plugin-dts";
import * as path from "node:path";
-import { createRequire } from "module";
import { visualizer } from "rollup-plugin-visualizer";
+import { version } from "./package.json";
+import { createRequire } from "module";
const require = createRequire(import.meta.url);
// These are the dependencies that will not be bundled into the library.
@@ -41,6 +42,9 @@ export default defineConfig({
server: {
port: 8012,
},
+ define: {
+ DOENETML_VERSION: JSON.stringify(version),
+ },
build: {
minify: false,
lib: {
diff --git a/packages/doenetml-prototype/vitest.workspace.ts b/packages/doenetml-prototype/vitest.workspace.ts
index 700e6b3d4..62a63ad47 100644
--- a/packages/doenetml-prototype/vitest.workspace.ts
+++ b/packages/doenetml-prototype/vitest.workspace.ts
@@ -1,12 +1,26 @@
+import { Plugin, PluginOption } from "vite";
import { defineWorkspace, defaultInclude } from "vitest/config";
+const omitCssPlugin: Plugin = {
+ name: "omit-css",
+ enforce: "pre",
+ transform(code, id) {
+ if (id.endsWith(".css")) {
+ return {
+ code: "",
+ };
+ }
+ },
+};
+
export default defineWorkspace([
{
// use vite.config.ts as a default config for all
extends: "./vite.config.ts",
test: {
name: "node",
- include: ["test/*.test.ts"],
+ include: ["test/*.test.ts", "test/*.test.tsx"],
+ testTimeout: 20000,
},
},
{
@@ -19,6 +33,11 @@ export default defineWorkspace([
name: "chrome",
headless: true,
},
+ testTimeout: 20000,
},
+ plugins: [
+ // vitest running in th browser won't transform CSS correctly, so we strip away all CSS files
+ omitCssPlugin,
+ ],
},
]);
diff --git a/packages/doenetml-worker-rust/lib-doenetml-core/src/core/core.rs b/packages/doenetml-worker-rust/lib-doenetml-core/src/core/core.rs
index d12410670..3b76d638e 100644
--- a/packages/doenetml-worker-rust/lib-doenetml-core/src/core/core.rs
+++ b/packages/doenetml-worker-rust/lib-doenetml-core/src/core/core.rs
@@ -46,6 +46,11 @@ impl Core {
flat_root.compactify();
let normalized_flat_root = flat_root.into_normalized_root();
+ // If we are initializing, we need to make sure that pre-existing data doesn't mess things up.
+ // The easiest way is to recreate ourself.
+ // TODO: think about whether we can update existing structures.
+ *self = Self::new();
+
let component_builder = ComponentBuilder::from_normalized_root(&normalized_flat_root);
self.document_model.init_from_builder(component_builder);
resolver
diff --git a/packages/doenetml-worker-rust/lib-doenetml-core/src/utils/logging.rs b/packages/doenetml-worker-rust/lib-doenetml-core/src/utils/logging.rs
index 819e7b90a..33d4d390f 100644
--- a/packages/doenetml-worker-rust/lib-doenetml-core/src/utils/logging.rs
+++ b/packages/doenetml-worker-rust/lib-doenetml-core/src/utils/logging.rs
@@ -1,4 +1,5 @@
/// Macros for logging.
+#[macro_export]
#[allow(unused)]
macro_rules! log {
( $( $t:tt )* ) => {
@@ -17,6 +18,7 @@ macro_rules! log {
}
}
}
+#[macro_export]
#[allow(unused)]
macro_rules! log_json {
( $label:expr, $a:expr ) => {
@@ -30,6 +32,7 @@ macro_rules! log_json {
}
};
}
+#[macro_export]
#[allow(unused)]
macro_rules! log_debug {
( $( $t:tt )* ) => {
@@ -46,9 +49,12 @@ macro_rules! log_debug {
}
}
+#[macro_export]
#[allow(unused)]
pub(crate) use log;
+#[macro_export]
#[allow(unused)]
pub(crate) use log_debug;
+#[macro_export]
#[allow(unused)]
pub(crate) use log_json;
diff --git a/packages/doenetml-worker-rust/lib-doenetml-core/tests/core_basics.rs b/packages/doenetml-worker-rust/lib-doenetml-core/tests/core_basics.rs
index 7a7673848..d28a54736 100644
--- a/packages/doenetml-worker-rust/lib-doenetml-core/tests/core_basics.rs
+++ b/packages/doenetml-worker-rust/lib-doenetml-core/tests/core_basics.rs
@@ -70,3 +70,21 @@ fn test_core_can_get_component_index_by_name() {
assert_eq!(core.get_component_index_by_name("t2"), 2);
assert_eq!(core.get_component_index_by_name("t3"), 3);
}
+
+#[test]
+fn test_can_change_source_on_an_initialized_core() {
+ let dast_root1 = dast_root_no_position(r#""#);
+ let dast_root2 =
+ dast_root_no_position(r#""#);
+
+ let mut core = TestCore::new();
+ core.init_from_dast_root(&dast_root1);
+ core.to_flat_dast();
+
+ core.init_from_dast_root(&dast_root2);
+ core.to_flat_dast();
+
+ assert_eq!(core.get_component_index_by_name("t1"), 1);
+ assert_eq!(core.get_component_index_by_name("t2"), 2);
+ assert_eq!(core.get_component_index_by_name("t3"), 3);
+}
diff --git a/packages/doenetml-worker-rust/package.json b/packages/doenetml-worker-rust/package.json
index ec475394a..911adcb5c 100644
--- a/packages/doenetml-worker-rust/package.json
+++ b/packages/doenetml-worker-rust/package.json
@@ -101,6 +101,6 @@
"rollup-plugin-polyfill-node": "^0.13.0",
"vite": "^5.3.3",
"vite-plugin-static-copy": "^1.0.6",
- "webdriverio": "^8.38.2"
+ "webdriverio": "^8.39.1"
}
}
diff --git a/packages/doenetml/package.json b/packages/doenetml/package.json
index c0af1ce30..afd89f011 100644
--- a/packages/doenetml/package.json
+++ b/packages/doenetml/package.json
@@ -85,7 +85,7 @@
"nanoid": "^4.0.2",
"prismjs": "^1.29.0",
"react-copy-to-clipboard": "^5.0.3",
- "react-icons": "^4.12.0",
+ "react-icons": "^5.2.1",
"react-mathquill": "^1.0.3",
"react-measure": "^2.5.2",
"react-router": "^6.24.1",
diff --git a/packages/parser/src/dast-to-xml/dast-util-to-xml.ts b/packages/parser/src/dast-to-xml/dast-util-to-xml.ts
index 1d7327244..3fce01eea 100644
--- a/packages/parser/src/dast-to-xml/dast-util-to-xml.ts
+++ b/packages/parser/src/dast-to-xml/dast-util-to-xml.ts
@@ -38,7 +38,7 @@ export function toXml(
* Serialize a node.
*/
export function nodesToXml(
- node: DastNodes | DastNodes[],
+ node: DastNodes | DastNodes[] | DastAttribute,
options: PrintOptions,
): string {
if (Array.isArray(node)) {
@@ -80,6 +80,9 @@ export function nodesToXml(
return result + ">";
}
+ case "attribute": {
+ return attrToString(node, options);
+ }
case "element": {
const nodeName = name(node.name);
const content = nodesToXml(node.children, options);
diff --git a/packages/virtual-keyboard/package.json b/packages/virtual-keyboard/package.json
index 9081c3da7..d14d040db 100644
--- a/packages/virtual-keyboard/package.json
+++ b/packages/virtual-keyboard/package.json
@@ -54,7 +54,7 @@
"better-react-mathjax": "^2.0.3",
"@fortawesome/react-fontawesome": "^0.2.2",
"@fortawesome/free-solid-svg-icons": "^6.5.2",
- "react-icons": "^4.12.0"
+ "react-icons": "^5.2.1"
},
"devDependencies": {}
}