@erudit-js/prose 4.1.1 → 4.2.0

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

@@ -1,429 +1,82 @@
-import { type AnySchema, type NormalizedChildren, type TagChildren } from '@jsprose/core';
+import { type BlockSchema, type NormalizedChildren, type Schema } from 'tsprose';
+import { type UppercaseFirst } from '../../utils/case.js';
 import { problemCheckSchema } from './problemCheck.js';
-export declare const problemDescription: {
-    schema: {
-        name: "problemDescription";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    };
-    tag: import("@jsprose/core").Tag<"ProblemDescription", {
-        name: "problemDescription";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemDescription";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemDescription: import("@jsprose/core").Tag<"ProblemDescription", {
-            name: "problemDescription";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
-    coreElement: {
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: "problemDescription";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            ProblemDescription: import("@jsprose/core").Tag<"ProblemDescription", {
-                name: "problemDescription";
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, TagChildren>;
-        }, undefined>;
-    };
-};
-export declare const problemHint: {
-    schema: {
-        name: "problemHint";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    };
-    tag: import("@jsprose/core").Tag<"ProblemHint", {
-        name: "problemHint";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemHint";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemHint: import("@jsprose/core").Tag<"ProblemHint", {
-            name: "problemHint";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
-    coreElement: {
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: "problemHint";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            ProblemHint: import("@jsprose/core").Tag<"ProblemHint", {
-                name: "problemHint";
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, TagChildren>;
-        }, undefined>;
-    };
-};
-export declare const problemDescriptionSchema: {
-    name: "problemDescription";
-    type: "block";
-    linkable: false;
-    Data: undefined;
-    Storage: undefined;
-    Children: AnySchema[];
-}, ProblemDescription: import("@jsprose/core").Tag<"ProblemDescription", {
-    name: "problemDescription";
-    type: "block";
-    linkable: false;
-    Data: undefined;
-    Storage: undefined;
-    Children: AnySchema[];
-}, TagChildren>, problemDescriptionRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "problemDescription";
-    type: "block";
+export interface ProblemDescriptionSchema extends Schema {
+    name: 'problemDescription';
+    type: 'block';
     linkable: false;
     Data: undefined;
     Storage: undefined;
-    Children: AnySchema[];
-}, {
-    ProblemDescription: import("@jsprose/core").Tag<"ProblemDescription", {
-        name: "problemDescription";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-}, undefined>, problemDescriptionCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemDescription";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemDescription: import("@jsprose/core").Tag<"ProblemDescription", {
-            name: "problemDescription";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
+    Children: BlockSchema[];
+}
+export declare const problemDescriptionSchema: ProblemDescriptionSchema;
+export declare const ProblemDescription: import("../../tag.js").ToEruditTag<ProblemDescriptionSchema, "ProblemDescription", unknown>;
+export declare const problemDescriptionCoreElement: {
+    readonly schema: ProblemDescriptionSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<ProblemDescriptionSchema, "ProblemDescription", unknown>];
 };
-export declare const problemHintSchema: {
-    name: "problemHint";
-    type: "block";
+export interface ProblemHintSchema extends Schema {
+    name: 'problemHint';
+    type: 'block';
     linkable: false;
     Data: undefined;
     Storage: undefined;
-    Children: AnySchema[];
-}, ProblemHint: import("@jsprose/core").Tag<"ProblemHint", {
-    name: "problemHint";
-    type: "block";
-    linkable: false;
-    Data: undefined;
-    Storage: undefined;
-    Children: AnySchema[];
-}, TagChildren>, problemHintRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "problemHint";
-    type: "block";
-    linkable: false;
-    Data: undefined;
-    Storage: undefined;
-    Children: AnySchema[];
-}, {
-    ProblemHint: import("@jsprose/core").Tag<"ProblemHint", {
-        name: "problemHint";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-}, undefined>, problemHintCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemHint";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemHint: import("@jsprose/core").Tag<"ProblemHint", {
-            name: "problemHint";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
+    Children: BlockSchema[];
+}
+export declare const problemHintSchema: ProblemHintSchema;
+export declare const ProblemHint: import("../../tag.js").ToEruditTag<ProblemHintSchema, "ProblemHint", unknown>;
+export declare const problemHintCoreElement: {
+    readonly schema: ProblemHintSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<ProblemHintSchema, "ProblemHint", unknown>];
 };
-export declare const problemSectionSchema: {
-    name: "problemSection";
-    type: "block";
+export interface ProblemSectionSchema extends Schema {
+    name: 'problemSection';
+    type: 'block';
     linkable: false;
     Data: string;
     Storage: undefined;
-    Children: AnySchema[];
-};
-export declare const ProblemSection: import("@jsprose/core").Tag<"ProblemSection", {
-    name: "problemSection";
-    type: "block";
-    linkable: false;
-    Data: string;
-    Storage: undefined;
-    Children: AnySchema[];
-}, {
+    Children: BlockSchema[];
+}
+export declare const problemSectionSchema: ProblemSectionSchema;
+export declare const ProblemSection: import("../../tag.js").ToEruditTag<ProblemSectionSchema, "ProblemSection", {
     title: string;
-} & TagChildren>;
-export declare const problemSectionRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "problemSection";
-    type: "block";
-    linkable: false;
-    Data: string;
-    Storage: undefined;
-    Children: AnySchema[];
-}, {
-    ProblemSection: import("@jsprose/core").Tag<"ProblemSection", {
-        name: "problemSection";
-        type: "block";
-        linkable: false;
-        Data: string;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        title: string;
-    } & TagChildren>;
-}, undefined>;
+}>;
 export declare const problemSectionCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemSection";
-        type: "block";
-        linkable: false;
-        Data: string;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemSection: import("@jsprose/core").Tag<"ProblemSection", {
-            name: "problemSection";
-            type: "block";
-            linkable: false;
-            Data: string;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            title: string;
-        } & TagChildren>;
-    }, undefined>;
+    readonly schema: ProblemSectionSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<ProblemSectionSchema, "ProblemSection", {
+        title: string;
+    }>];
 };
+export interface SectionContainerSchema<ContainerName extends string> extends Schema {
+    name: `problem${UppercaseFirst<ContainerName>}`;
+    type: 'block';
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: BlockSchema[];
+}
 export declare const problemNote: {
-    schema: {
-        name: "problemNote";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    };
-    tag: import("@jsprose/core").Tag<"ProblemNote", {
-        name: "problemNote";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemNote";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemNote: import("@jsprose/core").Tag<"ProblemNote", {
-            name: "problemNote";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
+    schema: SectionContainerSchema<"note">;
+    tag: import("../../tag.js").ToEruditTag<SectionContainerSchema<"note">, "ProblemNote", unknown>;
     coreElement: {
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: "problemNote";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            ProblemNote: import("@jsprose/core").Tag<"ProblemNote", {
-                name: "problemNote";
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, TagChildren>;
-        }, undefined>;
+        readonly schema: SectionContainerSchema<"note">;
+        readonly tags: [import("../../tag.js").ToEruditTag<SectionContainerSchema<"note">, "ProblemNote", unknown>];
     };
 };
 export declare const problemSolution: {
-    schema: {
-        name: "problemSolution";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    };
-    tag: import("@jsprose/core").Tag<"ProblemSolution", {
-        name: "problemSolution";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemSolution";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemSolution: import("@jsprose/core").Tag<"ProblemSolution", {
-            name: "problemSolution";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
+    schema: SectionContainerSchema<"solution">;
+    tag: import("../../tag.js").ToEruditTag<SectionContainerSchema<"solution">, "ProblemSolution", unknown>;
     coreElement: {
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: "problemSolution";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            ProblemSolution: import("@jsprose/core").Tag<"ProblemSolution", {
-                name: "problemSolution";
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, TagChildren>;
-        }, undefined>;
+        readonly schema: SectionContainerSchema<"solution">;
+        readonly tags: [import("../../tag.js").ToEruditTag<SectionContainerSchema<"solution">, "ProblemSolution", unknown>];
     };
 };
 export declare const problemAnswer: {
-    schema: {
-        name: "problemAnswer";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    };
-    tag: import("@jsprose/core").Tag<"ProblemAnswer", {
-        name: "problemAnswer";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, TagChildren>;
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problemAnswer";
-        type: "block";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: AnySchema[];
-    }, {
-        ProblemAnswer: import("@jsprose/core").Tag<"ProblemAnswer", {
-            name: "problemAnswer";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-    }, undefined>;
+    schema: SectionContainerSchema<"answer">;
+    tag: import("../../tag.js").ToEruditTag<SectionContainerSchema<"answer">, "ProblemAnswer", unknown>;
     coreElement: {
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: "problemAnswer";
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            ProblemAnswer: import("@jsprose/core").Tag<"ProblemAnswer", {
-                name: "problemAnswer";
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, TagChildren>;
-        }, undefined>;
+        readonly schema: SectionContainerSchema<"answer">;
+        readonly tags: [import("../../tag.js").ToEruditTag<SectionContainerSchema<"answer">, "ProblemAnswer", unknown>];
     };
 };
 export type ProblemContentChild = typeof problemDescriptionSchema | typeof problemHintSchema | typeof problemNote.schema | typeof problemSolution.schema | typeof problemAnswer.schema | typeof problemCheckSchema;

package/dist/elements/problem/problemContent.js

@@ -1,78 +1,68 @@
-import { defineRegistryItem, defineSchema, ensureTagChildren, isRawElement, ProseError } from "@jsprose/core";
+import { defineSchema, ensureTagBlockChildren, ensureTagChildren, isRawElement } from "tsprose";
 import { defineEruditTag } from "../../tag.js";
-import { defineEruditProseCoreElement } from "../../coreElement.js";
 import { uppercaseFirst } from "../../utils/case.js";
-import { tryParagraphWrap } from "../../shared/paragraphWrap.js";
+import { paragraphWrap } from "../../shared/paragraphWrap.js";
 import { problemCheckSchema } from "./problemCheck.js";
-/* --------------------------------------------------------- */
-/* shared helpers                                            */
-/* --------------------------------------------------------- */
-function defineParagraphBlock(opts) {
-	const schema = defineSchema({
-		name: opts.name,
-		type: "block",
-		linkable: false
-	})();
-	const tag = defineEruditTag({
-		tagName: opts.tagName,
-		schema
-	})(({ element, tagName, children }) => {
-		ensureTagChildren(tagName, children);
-		element.children = tryParagraphWrap(children) ?? children;
-	});
-	const registryItem = defineRegistryItem({
-		schema,
-		tags: [tag]
-	});
-	const coreElement = defineEruditProseCoreElement({ registryItem });
-	return {
-		schema,
-		tag,
-		registryItem,
-		coreElement
-	};
+import { defineProseCoreElement } from "../../coreElement.js";
+import { EruditProseError } from "../../error.js";
+function toBlockChildren(tagName, children) {
+	const wrap = paragraphWrap(children);
+	if (wrap) {
+		return wrap;
+	}
+	ensureTagBlockChildren(tagName, children);
+	return children;
 }
-/* --------------------------------------------------------- */
-/* description / hint                                        */
-/* --------------------------------------------------------- */
-export const problemDescription = defineParagraphBlock({
+export const problemDescriptionSchema = defineSchema({
 	name: "problemDescription",
+	type: "block",
+	linkable: false
+});
+export const ProblemDescription = defineEruditTag({
+	schema: problemDescriptionSchema,
 	tagName: "ProblemDescription"
+})(({ element, tagName, children }) => {
+	element.children = toBlockChildren(tagName, children);
+});
+export const problemDescriptionCoreElement = defineProseCoreElement({
+	schema: problemDescriptionSchema,
+	tags: [ProblemDescription]
 });
-export const problemHint = defineParagraphBlock({
+export const problemHintSchema = defineSchema({
 	name: "problemHint",
+	type: "block",
+	linkable: false
+});
+export const ProblemHint = defineEruditTag({
+	schema: problemHintSchema,
 	tagName: "ProblemHint"
+})(({ element, tagName, children }) => {
+	element.children = toBlockChildren(tagName, children);
+});
+export const problemHintCoreElement = defineProseCoreElement({
+	schema: problemHintSchema,
+	tags: [ProblemHint]
 });
-export const { schema: problemDescriptionSchema, tag: ProblemDescription, registryItem: problemDescriptionRegistryItem, coreElement: problemDescriptionCoreElement } = problemDescription;
-export const { schema: problemHintSchema, tag: ProblemHint, registryItem: problemHintRegistryItem, coreElement: problemHintCoreElement } = problemHint;
-/* --------------------------------------------------------- */
-/* section                                                   */
-/* --------------------------------------------------------- */
 export const problemSectionSchema = defineSchema({
 	name: "problemSection",
 	type: "block",
 	linkable: false
-})();
+});
 export const ProblemSection = defineEruditTag({
 	tagName: "ProblemSection",
 	schema: problemSectionSchema
 })(({ element, tagName, props, children }) => {
-	ensureTagChildren(tagName, children);
-	element.children = tryParagraphWrap(children) ?? children;
+	element.children = toBlockChildren(tagName, children);
 	const title = props.title.trim();
 	if (!title) {
-		throw new ProseError(`${tagName} title must be non-empty.`);
+		throw new EruditProseError(`${tagName} title must be non-empty.`);
 	}
 	element.data = title;
 });
-export const problemSectionRegistryItem = defineRegistryItem({
+export const problemSectionCoreElement = defineProseCoreElement({
 	schema: problemSectionSchema,
 	tags: [ProblemSection]
 });
-export const problemSectionCoreElement = defineEruditProseCoreElement({ registryItem: problemSectionRegistryItem });
-/* --------------------------------------------------------- */
-/* section containers                                        */
-/* --------------------------------------------------------- */
 function defineProblemSectionContainer(name) {
 	const cap = uppercaseFirst(name);
 	const schemaName = `problem${cap}`;
@@ -81,12 +71,12 @@ function defineProblemSectionContainer(name) {
 		name: schemaName,
 		type: "block",
 		linkable: false
-	})();
+	});
 	const tag = defineEruditTag({
 		tagName,
 		schema
 	})(({ element, children }) => {
-		const head = [];
+		const headRaw = [];
 		const sections = [];
 		let seenSection = false;
 		for (const child of children) {
@@ -95,22 +85,21 @@ function defineProblemSectionContainer(name) {
 				sections.push(child);
 			} else {
 				if (seenSection) {
-					throw new ProseError(`${tagName}: non-section children must come before <ProblemSection>.`);
+					throw new EruditProseError(`${tagName}: non-section children must come before <ProblemSection>.`);
 				}
-				head.push(child);
+				headRaw.push(child);
 			}
 		}
-		element.children = [...tryParagraphWrap(head) ?? head, ...sections];
+		const head = headRaw.length > 0 ? toBlockChildren(tagName, headRaw) : [];
+		element.children = [...head, ...sections];
 	});
-	const registryItem = defineRegistryItem({
+	const coreElement = defineProseCoreElement({
 		schema,
 		tags: [tag]
 	});
-	const coreElement = defineEruditProseCoreElement({ registryItem });
 	return {
 		schema,
 		tag,
-		registryItem,
 		coreElement
 	};
 }
@@ -145,7 +134,7 @@ export function validateProblemContent(source, children) {
 		for (const { schema, label } of uniques) {
 			if (isRawElement(child, schema)) {
 				if (seen.has(label)) {
-					throw new ProseError(`Invalid problem content at ${source}: only one <${label}> allowed.`);
+					throw new EruditProseError(`Invalid problem content at ${source}: only one <${label}> allowed.`);
 				}
 				seen.add(label);
 				break;