@erudit-js/prose 4.1.1 → 4.2.0

package/dist/elements/paragraph/core.js

@@ -1,16 +1,16 @@
-import { defineRegistryItem, defineSchema, ensureTagInlinerChildren } from "@jsprose/core";
-import { defineEruditProseCoreElement } from "../../coreElement.js";
+import { defineSchema, ensureTagInlinerChildren } from "tsprose";
 import { defineEruditTag } from "../../tag.js";
+import { defineProseCoreElement } from "../../coreElement.js";
 export const paragraphSchema = defineSchema({
 	name: "paragraph",
 	type: "block",
 	linkable: true
-})();
+});
 export const P = defineEruditTag({
 	tagName: "P",
 	schema: paragraphSchema
-})(({ element, tagName, props, children, registry }) => {
-	ensureTagInlinerChildren(tagName, children, registry);
+})(({ element, tagName, props, children }) => {
+	ensureTagInlinerChildren(tagName, children);
 	element.children = children;
 	if (props.center || props.serif) {
 		element.data = {};
@@ -22,8 +22,7 @@ export const P = defineEruditTag({
 		}
 	}
 });
-export const paragraphRegistryItem = defineRegistryItem({
+export default defineProseCoreElement({
 	schema: paragraphSchema,
 	tags: [P]
 });
-export default defineEruditProseCoreElement({ registryItem: paragraphRegistryItem });

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

@@ -1,30 +1,2 @@
-declare const _default: (import("../../app/appElement.js").AppElement<{
-    name: "problem";
-    type: "block";
-    linkable: true;
-    Data: import("./problem.js").ProblemData;
-    Storage: import("./storage.js").ProblemScriptStorage;
-    Children: import("./problemContent.js").ProblemContentChild[];
-}> | import("../../app/appElement.js").AppElement<{
-    name: "problems";
-    type: "block";
-    linkable: true;
-    Data: import("./shared.js").ProblemInfo;
-    Storage: undefined;
-    Children: (import("@jsprose/core").BlockSchema | {
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: import("./problems.js").SubProblemData;
-        Storage: import("./storage.js").ProblemScriptStorage;
-        Children: import("./problemContent.js").ProblemContentChild[];
-    })[];
-}> | import("../../app/appElement.js").AppElement<{
-    name: "subProblem";
-    type: "block";
-    linkable: false;
-    Data: import("./problems.js").SubProblemData;
-    Storage: import("./storage.js").ProblemScriptStorage;
-    Children: import("./problemContent.js").ProblemContentChild[];
-}>)[];
+declare const _default: (import("../../app/appElement.js").ProseAppElement<import("./problem.js").ProblemSchema> | import("../../app/appElement.js").ProseAppElement<import("./problems.js").ProblemsSchema> | import("../../app/appElement.js").ProseAppElement<import("./problems.js").SubProblemSchema>)[];
 export default _default;

package/dist/elements/problem/app.js

@@ -1,9 +1,9 @@
-import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { defineProseAppElement } from "../../app/appElement.js";
 import { problemSchema } from "./problem.js";
 import { problemsSchema, subProblemSchema } from "./problems.js";
 const icon = () => import("./assets/icon.svg?raw");
 export default [
-	defineEruditProseAppElement({
+	defineProseAppElement({
 		schema: problemSchema,
 		component: () => import("./components/Problem.vue"),
 		icon,
@@ -12,7 +12,7 @@ export default [
 			ru: () => import("./languages/problem/ru.js")
 		}
 	}),
-	defineEruditProseAppElement({
+	defineProseAppElement({
 		schema: problemsSchema,
 		component: () => import("./components/Problems.vue"),
 		icon,
@@ -21,7 +21,7 @@ export default [
 			ru: () => import("./languages/problems/ru.js")
 		}
 	}),
-	defineEruditProseAppElement({
+	defineProseAppElement({
 		schema: subProblemSchema,
 		component: () => import("./components/SubProblem.vue")
 	})

package/dist/elements/problem/components/Problem.vue

@@ -1,14 +1,14 @@
 <script setup lang="ts">
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
-import { problemSchema } from '../problem.js';
+import { type ProblemSchema } from '../problem.js';
 import Block from '../../../app/shared/block/Block.vue';
 import ProblemContainer from './ProblemContainer.vue';
 import ProblemHeader from './ProblemHeader.vue';
 import ProblemContent from './ProblemContent.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof problemSchema>;
+  element: ToProseElement<ProblemSchema>;
 }>();
 </script>
 

package/dist/elements/problem/components/ProblemContent.vue

@@ -7,11 +7,7 @@ import {
   watchEffect,
   type Component,
 } from 'vue';
-import {
-  isProseElement,
-  resolveRawElement,
-  type ProseElement,
-} from '@jsprose/core';
+import { isProseElement, type ToProseElement } from 'tsprose';
 
 import {
   problemAnswer,
@@ -28,7 +24,7 @@ import { useProblemPhrase } from '../composables/phrase.js';
 import type { ProblemAction } from '../shared.js';
 import { useArrayContainsAnchor } from '../../../app/composables/anchor.js';
 import type { ProblemScriptInstance } from '../problemScript.js';
-import type { problemSchema } from '../problem.js';
+import type { ProblemSchema } from '../problem.js';
 import type { subProblemSchema } from '../problems.js';
 import { useElementStorage } from '../../../app/composables/storage.js';
 import type { ProblemScriptStorage } from '../storage.js';
@@ -40,12 +36,13 @@ import DefaultPlusSections from './expanders/DefaultPlusSections.vue';
 import ProblemButton from './ProblemButton.vue';
 import Checks from './expanders/Checks.vue';
 import ProblemButtonGenerate from './ProblemButtonGenerate.vue';
+import { eruditRawToProse } from '../../../rawToProse/index.js';
 
 const { element, initialElements } = defineProps<{
   element:
-    | ProseElement<typeof problemSchema>
-    | ProseElement<typeof subProblemSchema>;
-  initialElements: ProseElement<ProblemContentChild>[];
+    | ToProseElement<ProblemSchema>
+    | ToProseElement<typeof subProblemSchema>;
+  initialElements: ToProseElement<ProblemContentChild>[];
 }>();
 
 const { EruditIcon } = useProseContext();
@@ -67,7 +64,7 @@ const actionIcons: Record<ProblemAction, string> = Object.fromEntries(
 
 const key = ref(0);
 const elements =
-  shallowRef<ProseElement<ProblemContentChild>[]>(initialElements);
+  shallowRef<ToProseElement<ProblemContentChild>[]>(initialElements);
 
 const description = computed(() => {
   return elements.value.find((element) =>
@@ -93,12 +90,12 @@ const expandableActions = computed(() => {
       : never;
 
   const actionMap: ActionMap<{
-    hint?: ProseElement<typeof problemHintSchema>[];
-    answer?: ProseElement<typeof problemAnswer.schema>;
-    solution?: ProseElement<typeof problemSolution.schema>;
-    note?: ProseElement<typeof problemNote.schema>;
+    hint?: ToProseElement<typeof problemHintSchema>[];
+    answer?: ToProseElement<typeof problemAnswer.schema>;
+    solution?: ToProseElement<typeof problemSolution.schema>;
+    note?: ToProseElement<typeof problemNote.schema>;
     check?: {
-      checkElements: ProseElement<typeof problemCheckSchema>[];
+      checkElements: ToProseElement<typeof problemCheckSchema>[];
       checkFunction?: CheckFunction;
     };
   }> = {};
@@ -207,13 +204,10 @@ async function doGenerate(seed: ProblemSeed) {
   }
 
   const rawElements = generateResult.problemContent;
-  const proseElements: ProseElement<ProblemContentChild>[] = [];
+  const proseElements: ToProseElement<ProblemContentChild>[] = [];
   for (const rawElement of rawElements) {
-    const resolveResult = await resolveRawElement({
-      rawElement,
-      linkable: false,
-    });
-    proseElements.push(resolveResult.proseElement as any);
+    const resolveResult = await eruditRawToProse({ rawProse: rawElement });
+    proseElements.push(resolveResult.prose as any);
   }
 
   if (currentSeed !== seed) {

package/dist/elements/problem/components/ProblemExpanderSection.vue

@@ -1,6 +1,6 @@
 <script lang="ts" setup>
 import { ref, watchEffect } from 'vue';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 import plusIcon from '../../../app/shared/assets/plus.svg?raw';
 import { useProseContext } from '../../../app/composables/context.js';
@@ -10,7 +10,7 @@ import Render from '../../../app/shared/Render.vue';
 
 const { element } = defineProps<{
   title: string;
-  element: ProseElement<AnySchema>;
+  element: ProseElement;
 }>();
 
 const formatText = useFormatText();

package/dist/elements/problem/components/Problems.vue

@@ -2,11 +2,15 @@
 import { ref, watchEffect } from 'vue';
 import {
   isProseElement,
-  type BlockSchema,
-  type ProseElement,
-} from '@jsprose/core';
+  type BlockProseElement,
+  type ToProseElement,
+} from 'tsprose';
 
-import { subProblemSchema, type problemsSchema } from '../problems.js';
+import {
+  subProblemSchema,
+  type ProblemsSchema,
+  type SubProblemSchema,
+} from '../problems.js';
 import { useFormatText } from '../../../app/composables/formatText.js';
 import { useArrayContainsAnchor } from '../../../app/composables/anchor.js';
 import SubProblem from './SubProblem.vue';
@@ -17,18 +21,18 @@ import Render from '../../../app/shared/Render.vue';
 import ProblemButton from './ProblemButton.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof problemsSchema>;
+  element: ToProseElement<ProblemsSchema>;
 }>();
 
 const formatText = useFormatText();
 
 const sharedChildren = element.children.filter(
   (child) => !isProseElement(child, subProblemSchema),
-) as ProseElement<BlockSchema>[];
+) as BlockProseElement[];
 
 const subProblems = element.children.filter((child) =>
   isProseElement(child, subProblemSchema),
-) as ProseElement<typeof subProblemSchema>[];
+) as ToProseElement<SubProblemSchema>[];
 
 const activeSubProblemI = ref(0);
 

package/dist/elements/problem/components/SubProblem.vue

@@ -1,11 +1,10 @@
 <script lang="ts" setup>
-import type { ProseElement } from '@jsprose/core';
-
-import type { subProblemSchema } from '../problems.js';
+import type { ToProseElement } from 'tsprose';
+import type { SubProblemSchema } from '../problems.js';
 import ProblemContent from './ProblemContent.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof subProblemSchema>;
+  element: ToProseElement<SubProblemSchema>;
 }>();
 </script>
 

package/dist/elements/problem/components/expanders/Check.vue

@@ -1,11 +1,11 @@
 <script setup lang="ts">
 import { useTemplateRef, ref, watch, computed } from 'vue';
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import {
   checkProblemAnswer,
   fromSerializableValidator,
-  type problemCheckSchema,
+  type ProblemCheckSchema,
 } from '../../problemCheck.js';
 import checkIcon from '../../assets/actions/check.svg?raw';
 import plusIcon from '../../../../app/shared/assets/plus.svg?raw';
@@ -25,7 +25,7 @@ type CheckState = {
 };
 
 const { check, script } = defineProps<{
-  check: ProseElement<typeof problemCheckSchema>;
+  check: ToProseElement<ProblemCheckSchema>;
   script?: {
     check: (answer: string | undefined) => boolean;
     clear: () => void;

package/dist/elements/problem/components/expanders/Checks.vue

@@ -1,13 +1,16 @@
 <script setup lang="ts">
 import { computed, ref } from 'vue';
-import { isProseElement, type ProseElement } from '@jsprose/core';
+import { isProseElement, type ToProseElement } from 'tsprose';
 
 import type { CheckFunction } from '../../problemScript.js';
-import { problemCheckSchema } from '../../problemCheck.js';
+import {
+  problemCheckSchema,
+  type ProblemCheckSchema,
+} from '../../problemCheck.js';
 import ProblemExpander from '../ProblemExpander.vue';
 import Check from './Check.vue';
 
-type CheckProseElement = ProseElement<typeof problemCheckSchema>;
+type CheckProseElement = ToProseElement<ProblemCheckSchema>;
 type CheckStatus = 'default' | 'correct' | 'wrong';
 
 const { value } = defineProps<{

package/dist/elements/problem/components/expanders/DefaultPlusSections.vue

@@ -1,16 +1,12 @@
 <script lang="ts" setup>
-import {
-  isProseElement,
-  type AnySchema,
-  type ProseElement,
-} from '@jsprose/core';
+import { isProseElement, type ProseElement } from 'tsprose';
 
 import { problemSectionSchema } from '../../problemContent.js';
 import ProblemExpander from '../ProblemExpander.vue';
 import ProblemExpanderSection from '../ProblemExpanderSection.vue';
 import Render from '../../../../app/shared/Render.vue';
 
-const { value } = defineProps<{ value: ProseElement<AnySchema> }>();
+const { value } = defineProps<{ value: ProseElement }>();
 
 const defaultBlocks = value.children!.filter(
   (element) => !isProseElement(element, problemSectionSchema),
@@ -18,7 +14,7 @@ const defaultBlocks = value.children!.filter(
 
 const sections = value.children!.filter((element) =>
   isProseElement(element, problemSectionSchema),
-) as ProseElement<typeof problemSectionSchema>[];
+);
 </script>
 
 <template>

package/dist/elements/problem/components/expanders/Hint.vue

@@ -1,13 +1,13 @@
 <script lang="ts" setup>
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
-import type { problemHintSchema } from '../../problemContent.js';
+import type { ProblemHintSchema } from '../../problemContent.js';
 import { useProblemPhrase } from '../../composables/phrase.js';
 import ProblemExpander from '../ProblemExpander.vue';
 import Render from '../../../../app/shared/Render.vue';
 import ProblemExpanderSection from '../ProblemExpanderSection.vue';
 
-defineProps<{ value: ProseElement<typeof problemHintSchema>[] }>();
+defineProps<{ value: ToProseElement<ProblemHintSchema>[] }>();
 const phrase = await useProblemPhrase();
 </script>
 

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

@@ -1,3 +1,3 @@
-import type { AnyUnique } from '@jsprose/core';
+import type { Unique } from 'tsprose';
 import type { ProblemScriptInstance } from '../problemScript.js';
-export declare function createProblemScriptInstance(scriptUrl?: string, scriptUniques?: Record<string, AnyUnique>): Promise<ProblemScriptInstance | undefined>;
+export declare function createProblemScriptInstance(scriptUrl?: string, scriptUniques?: Record<string, Unique>): Promise<ProblemScriptInstance | undefined>;