@erudit-js/prose 4.1.1 → 4.2.0-dev.1

package/dist/elements/accent/core.d.ts

@@ -1,14 +1,21 @@
-import { type AnySchema, type BlockSchema, type ProseElement, type TagChildren } from '@jsprose/core';
+import { type ProseElement, type Schema, type ToProseElement } from 'tsprose';
 import { type UppercaseFirst } from '../../utils/case.js';
 export interface AccentDefinition<TName extends string, TSectionNames extends readonly string[]> {
     name: TName;
     sectionNames: TSectionNames;
 }
-export type AccentMainSchema = Omit<BlockSchema, 'Data' | 'linkable'> & {
+export interface AccentMainSchema<AccentName extends string = string> extends Schema {
+    name: `accentMain_${AccentName}`;
+    type: 'block';
     linkable: false;
     Data: undefined;
-};
-export type AccentSectionSchema = Omit<BlockSchema, 'Data' | 'linkable'> & {
+    Storage: undefined;
+    Children: Schema[];
+}
+export declare function isAccentMainElement(element: ProseElement): element is ToProseElement<AccentMainSchema>;
+export interface AccentSectionSchema<AccentName extends string = string> extends Schema {
+    name: `accentSection_${AccentName}`;
+    type: 'block';
     linkable: false;
     Data: {
         type: 'named';
@@ -17,324 +24,78 @@ export type AccentSectionSchema = Omit<BlockSchema, 'Data' | 'linkable'> & {
         type: 'manual';
         title: string;
     };
-};
-export type AccentSchema = Omit<BlockSchema, 'Data' | 'Children' | 'linkable'> & {
+    Storage: undefined;
+    Children: Schema[];
+}
+export declare function isAccentSectionElement(element: ProseElement): element is ToProseElement<AccentSectionSchema>;
+export interface AccentSchema<AccentName extends string = string> extends Schema {
+    name: `accent_${AccentName}`;
+    type: 'block';
     linkable: true;
     Data: {
         title: string;
         layout: 'column' | 'row';
     };
-    Children: (AccentMainSchema | AccentSectionSchema)[];
+    Storage: undefined;
+    Children: [
+        AccentMainSchema<AccentName>,
+        ...AccentSectionSchema<AccentName>[]
+    ];
     SectionNames: string[];
-};
-export declare function isAccentElement(element: ProseElement<AnySchema>): element is ProseElement<AccentSchema>;
-export declare function isAccentMainElement(element: ProseElement<AnySchema>): element is ProseElement<AccentMainSchema>;
-export declare function isAccentSectionElement(element: ProseElement<AnySchema>): element is ProseElement<AccentSectionSchema>;
-export declare function defineAccentCore<const I extends string, const J extends string[], const TDefinition extends AccentDefinition<I, J>>(definition: TDefinition): {
-    _sectionNames: TDefinition["sectionNames"];
+}
+export declare function isAccentElement(element: any): element is ToProseElement<AccentSchema>;
+export declare function defineAccentCore<const TName extends string, const TSectionNames extends string[]>(definition: AccentDefinition<TName, TSectionNames>): {
+    _sectionNames: TSectionNames;
     accent: {
-        schema: {
-            name: `accent_${TDefinition["name"]}`;
-            type: "block";
-            linkable: true;
-            Data: {
-                title: string;
-                layout: "column" | "row";
-            };
-            Storage: undefined;
-            Children: [{
-                name: `accentMain_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, ...{
-                name: `accentSection_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: {
-                    type: "named";
-                    name: string;
-                } | {
-                    type: "manual";
-                    title: string;
-                };
-                Storage: undefined;
-                Children: AnySchema[];
-            }[]];
-        } & {
-            SectionNames: TDefinition["sectionNames"];
+        schema: Omit<AccentSchema<TName>, "SectionNames"> & {
+            SectionNames: TSectionNames;
         };
-        tag: import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}`, {
-            name: `accent_${TDefinition["name"]}`;
-            type: "block";
-            linkable: true;
-            Data: {
-                title: string;
-                layout: "column" | "row";
-            };
-            Storage: undefined;
-            Children: [{
-                name: `accentMain_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, ...{
-                name: `accentSection_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: {
-                    type: "named";
-                    name: string;
-                } | {
-                    type: "manual";
-                    title: string;
-                };
-                Storage: undefined;
-                Children: AnySchema[];
-            }[]];
-        } & {
-            SectionNames: TDefinition["sectionNames"];
-        }, ({
+        tag: import("../../tag.js").ToEruditTag<Omit<AccentSchema<TName>, "SectionNames"> & {
+            SectionNames: TSectionNames;
+        }, UppercaseFirst<TName>, {
             title: string;
-        } & (({
+        } & ({
             row?: true;
             column?: undefined;
         } | {
             row?: undefined;
             column?: true;
-        }) & TagChildren)) & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: `accent_${TDefinition["name"]}`;
-            type: "block";
-            linkable: true;
-            Data: {
-                title: string;
-                layout: "column" | "row";
+        })>;
+        coreElement: {
+            readonly schema: Omit<AccentSchema<TName>, "SectionNames"> & {
+                SectionNames: TSectionNames;
             };
-            Storage: undefined;
-            Children: [{
-                name: `accentMain_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, ...{
-                name: `accentSection_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: {
-                    type: "named";
-                    name: string;
-                } | {
-                    type: "manual";
-                    title: string;
-                };
-                Storage: undefined;
-                Children: AnySchema[];
-            }[]];
-        } & {
-            SectionNames: TDefinition["sectionNames"];
-        }, { [K in `${UppercaseFirst<TDefinition["name"]>}`]: Extract<import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}`, {
-            name: `accent_${TDefinition["name"]}`;
-            type: "block";
-            linkable: true;
-            Data: {
+            readonly tags: [import("../../tag.js").ToEruditTag<Omit<AccentSchema<TName>, "SectionNames"> & {
+                SectionNames: TSectionNames;
+            }, UppercaseFirst<TName>, {
                 title: string;
-                layout: "column" | "row";
-            };
-            Storage: undefined;
-            Children: [{
-                name: `accentMain_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: undefined;
-                Storage: undefined;
-                Children: AnySchema[];
-            }, ...{
-                name: `accentSection_${TDefinition["name"]}`;
-                type: "block";
-                linkable: false;
-                Data: {
-                    type: "named";
-                    name: string;
-                } | {
-                    type: "manual";
-                    title: string;
-                };
-                Storage: undefined;
-                Children: AnySchema[];
-            }[]];
-        } & {
-            SectionNames: TDefinition["sectionNames"];
-        }, ({
-            title: string;
-        } & (({
-            row?: true;
-            column?: undefined;
-        } | {
-            row?: undefined;
-            column?: true;
-        }) & TagChildren)) & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>, {
-            tagName: K;
-        }>; }, undefined>;
+            } & ({
+                row?: true;
+                column?: undefined;
+            } | {
+                row?: undefined;
+                column?: true;
+            })>];
+        };
     };
     main: {
-        schema: {
-            name: `accentMain_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
+        schema: AccentMainSchema<TName>;
+        tag: import("../../tag.js").ToEruditTag<AccentMainSchema<TName>, `${UppercaseFirst<TName>}Main`, unknown>;
+        coreElement: {
+            readonly schema: AccentMainSchema<TName>;
+            readonly tags: [import("../../tag.js").ToEruditTag<AccentMainSchema<TName>, `${UppercaseFirst<TName>}Main`, unknown>];
         };
-        tag: import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}Main`, {
-            name: `accentMain_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>;
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: `accentMain_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, { [K_1 in `${UppercaseFirst<TDefinition["name"]>}Main`]: Extract<import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}Main`, {
-            name: `accentMain_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>, {
-            tagName: K_1;
-        }>; }, undefined>;
     };
     section: {
-        schema: {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        };
-        tags: [import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}Section`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
+        schema: AccentSectionSchema<TName>;
+        tags: [import("../../tag.js").ToEruditTag<AccentSectionSchema<TName>, `${UppercaseFirst<TName>}Section`, {
             title: string;
-        } & TagChildren>, ...{ [K_2 in TDefinition["sectionNames"][number]]: import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}${UppercaseFirst<K_2>}`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>; }[TDefinition["sectionNames"][number]][]];
-        registryItem: import("@jsprose/core").RegistryItem<{
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, { [K_3 in (import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}Section`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
+        }>, ...{ [K in TSectionNames[number]]: import("../../tag.js").ToEruditTag<AccentSectionSchema<TName>, `${UppercaseFirst<TName>}${UppercaseFirst<K>}`, unknown>; }[TSectionNames[number]][]];
+        coreElement: {
+            readonly schema: AccentSectionSchema<TName>;
+            readonly tags: [import("../../tag.js").ToEruditTag<AccentSectionSchema<TName>, `${UppercaseFirst<TName>}Section`, {
                 title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            title: string;
-        } & TagChildren> | { [K_2 in TDefinition["sectionNames"][number]]: import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}${UppercaseFirst<K_2>}`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>; }[TDefinition["sectionNames"][number]])["tagName"]]: Extract<import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}Section`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, {
-            title: string;
-        } & TagChildren>, {
-            tagName: K_3;
-        }> | Extract<{ [K_2 in TDefinition["sectionNames"][number]]: import("@jsprose/core").Tag<`${UppercaseFirst<TDefinition["name"]>}${UppercaseFirst<K_2>}`, {
-            name: `accentSection_${TDefinition["name"]}`;
-            type: "block";
-            linkable: false;
-            Data: {
-                type: "named";
-                name: string;
-            } | {
-                type: "manual";
-                title: string;
-            };
-            Storage: undefined;
-            Children: AnySchema[];
-        }, TagChildren>; }[TDefinition["sectionNames"][number]], {
-            tagName: K_3;
-        }>; }, undefined>;
+            }>, ...{ [K in TSectionNames[number]]: import("../../tag.js").ToEruditTag<AccentSectionSchema<TName>, `${UppercaseFirst<TName>}${UppercaseFirst<K>}`, unknown>; }[TSectionNames[number]][]];
+        };
     };
 };

package/dist/elements/accent/core.js

@@ -1,41 +1,52 @@
-import { defineRegistryItem, defineSchema, ensureTagChildren, ensureTagInlinerChildren, isRawElement, PROSE_REGISTRY, ProseError } from "@jsprose/core";
+import { defineSchema, ensureTagChildren, isRawElement } from "tsprose";
 import { defineEruditTag } from "../../tag.js";
 import { uppercaseFirst } from "../../utils/case.js";
-import { tryParagraphWrap } from "../../shared/paragraphWrap.js";
+import { paragraphWrap } from "../../shared/paragraphWrap.js";
+import { EruditProseError } from "../../error.js";
+import { defineProseCoreElement } from "../../coreElement.js";
 function validateTitle(tagName, title) {
 	if (!title) {
-		throw new ProseError(`<${tagName}> requires non-empty title attribute!`);
+		throw new EruditProseError(`<${tagName}> requires non-empty title attribute!`);
 	}
 }
-export function isAccentElement(element) {
-	return element.schemaName.startsWith("accent_");
-}
 export function isAccentMainElement(element) {
-	return element.schemaName.startsWith("accentMain_");
+	return element.schema.name.startsWith("accentMain_");
 }
 export function isAccentSectionElement(element) {
-	return element.schemaName.startsWith("accentSection_");
+	return element.schema.name.startsWith("accentSection_");
+}
+export function isAccentElement(element) {
+	const name = element?.schema?.name;
+	if (!name) {
+		return false;
+	}
+	return name.startsWith("accent_");
 }
 export function defineAccentCore(definition) {
 	// Accent name must start with lowercase
 	if (!/^[a-z]/.test(definition.name)) {
-		throw new ProseError(`
+		throw new EruditProseError(`
 Invalid accent name "${definition.name}"!
 Accent names should start with lower case letter.
             `.trim());
 	}
 	for (const sectionName of definition.sectionNames) {
 		if (sectionName === "section" || sectionName === "main") {
-			throw new ProseError(`Section names "section" and "main" are reserved for accent "${definition.name}"!`);
+			throw new EruditProseError(`Section names "section" and "main" are reserved for accent "${definition.name}"!`);
 		}
 		// Section name must start with lowercase
 		if (!/^[a-z]/.test(sectionName)) {
-			throw new ProseError(`
+			throw new EruditProseError(`
 Invalid section name "${sectionName}" for accent "${definition.name}"!
 Section names should start with lower case letter.
                 `.trim());
 		}
 	}
+	const Name = uppercaseFirst(definition.name);
+	function applyBlockChildren(tagName, children, element) {
+		ensureTagChildren(tagName, children);
+		element.children = paragraphWrap(children) ?? children;
+	}
 	//
 	// Schemas
 	//
@@ -43,42 +54,32 @@ Section names should start with lower case letter.
 		name: `accentMain_${definition.name}`,
 		type: "block",
 		linkable: false
-	})();
+	});
 	const sectionSchema = defineSchema({
 		name: `accentSection_${definition.name}`,
 		type: "block",
 		linkable: false
-	})();
-	const accentSchema = defineSchema({
+	});
+	const baseAccentSchema = defineSchema({
 		name: `accent_${definition.name}`,
 		type: "block",
 		linkable: true
-	})();
-	const typedAccentSchema = accentSchema;
+	});
+	const accentSchema = baseAccentSchema;
 	//
 	// Tags
 	//
 	const mainTag = defineEruditTag({
-		tagName: `${uppercaseFirst(definition.name)}Main`,
+		tagName: `${Name}Main`,
 		schema: mainSchema
 	})(({ tagName, element, children }) => {
-		ensureTagChildren(tagName, children);
-		element.children = children;
-		const paragraphWrap = tryParagraphWrap(children);
-		if (paragraphWrap) {
-			element.children = paragraphWrap;
-		}
+		applyBlockChildren(tagName, children, element);
 	});
 	const sectionTag = defineEruditTag({
-		tagName: `${uppercaseFirst(definition.name)}Section`,
+		tagName: `${Name}Section`,
 		schema: sectionSchema
 	})(({ tagName, element, props, children }) => {
-		ensureTagChildren(tagName, children);
-		element.children = children;
-		const paragraphWrap = tryParagraphWrap(children);
-		if (paragraphWrap) {
-			element.children = paragraphWrap;
-		}
+		applyBlockChildren(tagName, children, element);
 		const title = props.title.trim();
 		validateTitle(tagName, title);
 		element.data = {
@@ -88,67 +89,81 @@ Section names should start with lower case letter.
 	});
 	function createSuffixSectionTag(suffix) {
 		return defineEruditTag({
-			tagName: `${uppercaseFirst(definition.name)}${uppercaseFirst(suffix)}`,
+			tagName: `${Name}${uppercaseFirst(suffix)}`,
 			schema: sectionSchema
 		})(({ tagName, element, children }) => {
-			ensureTagChildren(tagName, children);
-			element.children = children;
-			const paragraphWrap = tryParagraphWrap(children);
-			if (paragraphWrap) {
-				element.children = paragraphWrap;
-			}
+			applyBlockChildren(tagName, children, element);
 			element.data = {
 				type: "named",
 				name: suffix
 			};
 		});
 	}
-	const namedSectionTags = Object.fromEntries(definition.sectionNames.map((sectionName) => {
-		const sectionTag = createSuffixSectionTag(sectionName);
-		return [sectionName, sectionTag];
-	}));
+	const namedSectionTags = Object.fromEntries(definition.sectionNames.map((sectionName) => [sectionName, createSuffixSectionTag(sectionName)]));
 	const sectionTags = [sectionTag, ...Object.values(namedSectionTags)];
 	const accentTag = defineEruditTag({
-		tagName: `${uppercaseFirst(definition.name)}`,
-		schema: typedAccentSchema
-	})(({ tagName, children, element, props, registry }) => {
-		try {
-			ensureTagChildren(tagName, children, [mainSchema, sectionSchema]);
-			element.children = children;
-			if (!isRawElement(element.children[0], mainSchema)) {
-				throw new ProseError(`<${tagName}> requires a <${mainTag.tagName}> as the first child element!`);
+		tagName: Name,
+		schema: accentSchema
+	})(({ tagName, children, element, props }) => {
+		ensureTagChildren(tagName, children);
+		let hasMainSchema = false;
+		let hasSectionSchema = false;
+		let hasOtherSchema = false;
+		for (const child of children) {
+			if (isRawElement(child, mainSchema)) {
+				if (hasMainSchema) {
+					throw new EruditProseError(`<${tagName}> can only have one <${mainTag.tagName}> child element!`);
+				}
+				hasMainSchema = true;
+				continue;
+			}
+			if (isRawElement(child, sectionSchema)) {
+				hasSectionSchema = true;
+				continue;
 			}
-		} catch {
-			element.children = [mainTag({
-				__JSPROSE_registryProp: PROSE_REGISTRY,
-				children
-			})];
+			hasOtherSchema = true;
+		}
+		if (hasOtherSchema) {
+			if (hasMainSchema || hasSectionSchema) {
+				throw new EruditProseError(`Cannot mix <${mainTag.tagName}> or <${sectionTag.tagName}> with other child elements inside <${tagName}>!`);
+			}
+			element.children = [mainTag({ children })];
+		} else {
+			let mainChild;
+			let sectionChildren = [];
+			for (const child of children) {
+				if (isRawElement(child, mainSchema)) {
+					mainChild = child;
+				} else if (isRawElement(child, sectionSchema)) {
+					sectionChildren.push(child);
+				}
+			}
+			if (!mainChild) {
+				throw new EruditProseError(`<${tagName}> requires a <${mainTag.tagName}> child element!`);
+			}
+			element.children = [mainChild, ...sectionChildren];
 		}
 		const title = props.title.trim();
 		validateTitle(tagName, title);
-		let layout = "column";
-		if (props.row === true) {
-			layout = "row";
-		}
 		element.data = {
 			title,
-			layout
+			layout: props.row === true ? "row" : "column"
 		};
 		element.title = title;
 	});
 	//
-	// Registry Items
+	// Core Elements
 	//
-	const mainRegistryItem = defineRegistryItem({
+	const mainCoreElement = defineProseCoreElement({
 		schema: mainSchema,
 		tags: [mainTag]
 	});
-	const sectionRegistryItem = defineRegistryItem({
+	const sectionCoreElement = defineProseCoreElement({
 		schema: sectionSchema,
 		tags: [sectionTag, ...Object.values(namedSectionTags)]
 	});
-	const accentRegistryItem = defineRegistryItem({
-		schema: typedAccentSchema,
+	const accentCoreElement = defineProseCoreElement({
+		schema: accentSchema,
 		tags: [accentTag]
 	});
 	//
@@ -157,19 +172,19 @@ Section names should start with lower case letter.
 	return {
 		_sectionNames: definition.sectionNames,
 		accent: {
-			schema: typedAccentSchema,
+			schema: accentSchema,
 			tag: accentTag,
-			registryItem: accentRegistryItem
+			coreElement: accentCoreElement
 		},
 		main: {
 			schema: mainSchema,
 			tag: mainTag,
-			registryItem: mainRegistryItem
+			coreElement: mainCoreElement
 		},
 		section: {
 			schema: sectionSchema,
 			tags: sectionTags,
-			registryItem: sectionRegistryItem
+			coreElement: sectionCoreElement
 		}
 	};
 }

package/dist/elements/callout/Callout.vue

@@ -1,16 +1,16 @@
 <script lang="ts" setup>
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
-import type { calloutSchema } from './core.js';
+import type { CalloutSchema } from './core.js';
 import { useElementStorage } from '../../app/composables/storage.js';
 import { useFormatText } from '../../app/composables/formatText.js';
 import Block from '../../app/shared/block/Block.vue';
 import Render from '../../app/shared/Render.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof calloutSchema>;
+  element: ToProseElement<CalloutSchema>;
 }>();
-const calloutStorage = await useElementStorage<typeof calloutSchema>(element);
+const calloutStorage = await useElementStorage(element);
 const formatText = useFormatText();
 </script>