@erudit-js/prose 4.1.1 → 4.2.0

package/dist/elements/list/core.js

@@ -1,49 +1,51 @@
-import { defineRegistryItem, defineSchema, ensureTagChildren } from "@jsprose/core";
+import { defineSchema, ensureTagBlockChildren, ensureTagChildren } from "tsprose";
 import { defineEruditTag } from "../../tag.js";
-import { defineEruditProseCoreElements } from "../../coreElement.js";
-import { tryParagraphWrap } from "../../shared/paragraphWrap.js";
+import { paragraphWrap } from "../../shared/paragraphWrap.js";
+import { defineProseCoreElements } from "../../coreElement.js";
 export const listItemSchema = defineSchema({
 	name: "listItem",
 	type: "block",
 	linkable: false
-})();
+});
 export const Li = defineEruditTag({
 	tagName: "Li",
 	schema: listItemSchema
 })(({ tagName, element, children }) => {
-	ensureTagChildren(tagName, children);
-	element.children = children;
-	const paragraphWrap = tryParagraphWrap(children);
-	if (paragraphWrap) {
-		element.children = paragraphWrap;
+	const wrap = paragraphWrap(children);
+	if (wrap) {
+		element.children = wrap;
+	} else {
+		ensureTagBlockChildren(tagName, children);
+		element.children = children;
 	}
 });
 export const listSchema = defineSchema({
 	name: "list",
 	type: "block",
 	linkable: true
-})();
+});
 export const List = defineEruditTag({
 	tagName: "List",
 	schema: listSchema
 })(({ element, tagName, props, children }) => {
 	ensureTagChildren(tagName, children, listItemSchema);
 	element.children = children;
-	if (props.type === "ol") {
+	if ("ordered" in props) {
 		element.data = {
-			type: "ol",
-			start: props.start ?? 1
+			type: "ordered",
+			start: "start" in props ? props.start : 1
 		};
 	} else {
-		element.data = { type: "ul" };
+		element.data = { type: "unordered" };
 	}
 });
-export const listItemRegistryItem = defineRegistryItem({
+//
+// Core Elements
+//
+export default defineProseCoreElements({
 	schema: listItemSchema,
 	tags: [Li]
-});
-export const listRegistryItem = defineRegistryItem({
+}, {
 	schema: listSchema,
 	tags: [List]
 });
-export default defineEruditProseCoreElements({ registryItem: listItemRegistryItem }, { registryItem: listRegistryItem });

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

@@ -1,16 +1,2 @@
-declare const _default: (import("../../app/appElement.js").AppElement<{
-    name: "blockMath";
-    type: "block";
-    linkable: true;
-    Data: import("./block.js").BlockMathData;
-    Storage: import("./block.js").MathGroup;
-    Children: undefined;
-}> | import("../../app/appElement.js").AppElement<{
-    name: "inlinerMath";
-    type: "inliner";
-    linkable: true;
-    Data: string;
-    Storage: import("./inliner.js").InlinerMathStorage;
-    Children: undefined;
-}>)[];
+declare const _default: (import("../../app/appElement.js").ProseAppElement<import("./block.js").BlockMathSchema> | import("../../app/appElement.js").ProseAppElement<import("./inliner.js").InlinerMathSchema>)[];
 export default _default;

package/dist/elements/math/app.js

@@ -1,7 +1,7 @@
-import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { defineProseAppElement } from "../../app/appElement.js";
 import { blockMathSchema } from "./block.js";
 import { inlinerMathSchema } from "./inliner.js";
-export default [defineEruditProseAppElement({
+export default [defineProseAppElement({
 	schema: blockMathSchema,
 	component: () => import("./components/BlockMath.vue"),
 	languages: {
@@ -9,7 +9,7 @@ export default [defineEruditProseAppElement({
 		ru: () => import("./languages/ru.js")
 	},
 	icon: () => import("./icon.svg?raw")
-}), defineEruditProseAppElement({
+}), defineProseAppElement({
 	schema: inlinerMathSchema,
 	component: () => import("./components/InlinerMath.vue"),
 	languages: {

package/dist/elements/math/block.d.ts

@@ -1,4 +1,4 @@
-import { type TagChildren } from '@jsprose/core';
+import { type RequiredChildren, type Schema } from 'tsprose';
 export declare const mathGroupTypes: readonly ["0", "small", "normal", "big"];
 export type MathGroupGapType = (typeof mathGroupTypes)[number] | 'custom';
 export type MathGroupAlignItems = 'top' | 'center' | 'bottom';
@@ -29,52 +29,40 @@ export interface MathGroup {
     parts: MathGroupPart[];
 }
 export declare function resolveMathGroups(katex: string, isTopLevel?: boolean): Promise<MathGroup | string>;
-export interface BlockMathData {
-    katex: string;
-    freeze?: boolean;
-}
-export declare const blockMathSchema: {
-    name: "blockMath";
-    type: "block";
-    linkable: true;
-    Data: BlockMathData;
-    Storage: MathGroup;
-    Children: undefined;
-};
-export declare const BlockMath: import("@jsprose/core").Tag<"BlockMath", {
-    name: "blockMath";
-    type: "block";
+export interface BlockMathSchema extends Schema {
+    name: 'blockMath';
+    type: 'block';
     linkable: true;
     Data: BlockMathData;
     Storage: MathGroup;
     Children: undefined;
-}, {
+}
+export interface BlockMathData {
+    katex: string;
     freeze?: boolean;
-} & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-export declare const blockMathRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "blockMath";
-    type: "block";
-    linkable: true;
-    Data: BlockMathData;
-    Storage: MathGroup;
-    Children: undefined;
-}, {
-    BlockMath: import("@jsprose/core").Tag<"BlockMath", {
-        name: "blockMath";
-        type: "block";
-        linkable: true;
-        Data: BlockMathData;
-        Storage: MathGroup;
-        Children: undefined;
-    }, {
+}
+export declare const blockMathSchema: BlockMathSchema;
+export declare const BlockMath: import("../../tag.js").ToEruditTag<BlockMathSchema, "BlockMath", {
+    freeze?: boolean;
+} & RequiredChildren>;
+export declare const blockMathCoreElement: {
+    readonly schema: BlockMathSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<BlockMathSchema, "BlockMath", {
         freeze?: boolean;
-    } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-}, (element: import("@jsprose/core").ProseElement<{
-    name: "blockMath";
-    type: "block";
-    linkable: true;
-    Data: BlockMathData;
-    Storage: MathGroup;
-    Children: undefined;
-}>) => Promise<MathGroup>>;
+    } & RequiredChildren>];
+    readonly createStorage: (element: {
+        schema: BlockMathSchema;
+        id: string;
+        data: BlockMathData;
+        storageKey: string;
+        children: undefined;
+        __TSPROSE_proseElement: true;
+    }) => Promise<MathGroup>;
+    readonly dependencies: {
+        katex: {
+            optimise: boolean;
+            transpile: boolean;
+        };
+    };
+};
 export declare function createBlockMathStorage(katex: string): Promise<MathGroup>;

package/dist/elements/math/block.js

@@ -1,6 +1,8 @@
-import { defineRegistryItem, defineSchema, ensureTagChild, ProseError, textSchema } from "@jsprose/core";
-import { latexToHtml, normalizeKatex } from "./katex.js";
+import { defineSchema, ensureTagChildren, textSchema } from "tsprose";
+import { katexDependency, latexToHtml, normalizeKatex } from "./katex.js";
 import { defineEruditTag } from "../../tag.js";
+import { EruditProseError } from "../../error.js";
+import { defineProseCoreElement } from "../../coreElement.js";
 export const mathGroupTypes = [
 	"0",
 	"small",
@@ -92,15 +94,15 @@ export const blockMathSchema = defineSchema({
 	name: "blockMath",
 	type: "block",
 	linkable: true
-})();
+});
 export const BlockMath = defineEruditTag({
 	tagName: "BlockMath",
 	schema: blockMathSchema
 })(({ element, tagName, props, children }) => {
-	ensureTagChild(tagName, children, textSchema);
+	ensureTagChildren(tagName, children, textSchema);
 	const katex = normalizeKatex(children[0].data);
 	if (!katex) {
-		throw new ProseError(`<${tagName}> tag must contain non-empty KaTeX math expression.`);
+		throw new EruditProseError(`<${tagName}> tag must contain non-empty KaTeX math expression.`);
 	}
 	element.data = {
 		katex,
@@ -108,12 +110,11 @@ export const BlockMath = defineEruditTag({
 	};
 	element.storageKey = `$$ ${katex} $$`;
 });
-export const blockMathRegistryItem = defineRegistryItem({
+export const blockMathCoreElement = defineProseCoreElement({
 	schema: blockMathSchema,
 	tags: [BlockMath],
-	async createStorage(element) {
-		return createBlockMathStorage(element.data.katex);
-	}
+	createStorage: async (element) => createBlockMathStorage(element.data.katex),
+	dependencies: katexDependency
 });
 export async function createBlockMathStorage(katex) {
 	let result = {

package/dist/elements/math/components/BlockMath.vue

@@ -1,21 +1,21 @@
 <script lang="ts" setup>
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import {
-  type blockMathSchema,
   type MathGroup as _MathGroup,
   createBlockMathStorage,
+  type BlockMathSchema,
 } from '../block.js';
 import { useElementStorage } from '../../../app/composables/storage.js';
 import MathGroup from './MathGroup.vue';
 import Block from '../../../app/shared/block/Block.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof blockMathSchema>;
+  element: ToProseElement<BlockMathSchema>;
 }>();
 
 const blockMathStorage =
-  (await useElementStorage<typeof blockMathSchema>(element)) ??
+  (await useElementStorage(element)) ??
   (await createBlockMathStorage(element.data.katex));
 
 const mathGroup: _MathGroup = blockMathStorage;

package/dist/elements/math/components/InlinerMath.vue

@@ -1,21 +1,21 @@
 <script lang="ts" setup>
 import 'katex/dist/katex.min.css';
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
 import Inliner from '../../../app/shared/inliner/Inliner.vue';
 import {
   createInlinerMathStorage,
-  type inlinerMathSchema,
+  type InlinerMathSchema,
 } from '../inliner.js';
 import { useElementStorage } from '../../../app/composables/storage.js';
 import Katex from './Katex.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof inlinerMathSchema>;
+  element: ToProseElement<InlinerMathSchema>;
 }>();
 
 const inlinerMathStorage =
-  (await useElementStorage<typeof inlinerMathSchema>(element)) ??
+  (await useElementStorage(element)) ??
   (await createInlinerMathStorage(element.data));
 </script>
 

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

@@ -1,62 +1,34 @@
-declare const _default: [{
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "inlinerMath";
-        type: "inliner";
-        linkable: true;
-        Data: string;
-        Storage: import("./inliner.js").InlinerMathStorage;
-        Children: undefined;
-    }, {
-        M: import("@jsprose/core").Tag<"M", {
-            name: "inlinerMath";
-            type: "inliner";
-            linkable: true;
-            Data: string;
-            Storage: import("./inliner.js").InlinerMathStorage;
-            Children: undefined;
-        }, import("@jsprose/core").TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-    }, (element: import("@jsprose/core").ProseElement<{
-        name: "inlinerMath";
-        type: "inliner";
-        linkable: true;
-        Data: string;
-        Storage: import("./inliner.js").InlinerMathStorage;
-        Children: undefined;
-    }>) => Promise<import("./inliner.js").InlinerMathStorage>>;
-    dependencies: {
+declare const _default: readonly [{
+    readonly schema: import("./block.js").BlockMathSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<import("./block.js").BlockMathSchema, "BlockMath", {
+        freeze?: boolean;
+    } & import("tsprose").RequiredChildren>];
+    readonly createStorage: (element: {
+        schema: import("./block.js").BlockMathSchema;
+        id: string;
+        data: import("./block.js").BlockMathData;
+        storageKey: string;
+        children: undefined;
+        __TSPROSE_proseElement: true;
+    }) => Promise<import("./block.js").MathGroup>;
+    readonly dependencies: {
         katex: {
             optimise: boolean;
             transpile: boolean;
         };
     };
 }, {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "blockMath";
-        type: "block";
-        linkable: true;
-        Data: import("./block.js").BlockMathData;
-        Storage: import("./block.js").MathGroup;
-        Children: undefined;
-    }, {
-        BlockMath: import("@jsprose/core").Tag<"BlockMath", {
-            name: "blockMath";
-            type: "block";
-            linkable: true;
-            Data: import("./block.js").BlockMathData;
-            Storage: import("./block.js").MathGroup;
-            Children: undefined;
-        }, {
-            freeze?: boolean;
-        } & import("@jsprose/core").TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-    }, (element: import("@jsprose/core").ProseElement<{
-        name: "blockMath";
-        type: "block";
-        linkable: true;
-        Data: import("./block.js").BlockMathData;
-        Storage: import("./block.js").MathGroup;
-        Children: undefined;
-    }>) => Promise<import("./block.js").MathGroup>>;
-    dependencies: {
+    readonly schema: import("./inliner.js").InlinerMathSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<import("./inliner.js").InlinerMathSchema, "M", import("tsprose").RequiredChildren>];
+    readonly createStorage: (element: {
+        schema: import("./inliner.js").InlinerMathSchema;
+        id: string;
+        data: string;
+        storageKey: string;
+        children: undefined;
+        __TSPROSE_proseElement: true;
+    }) => Promise<import("./inliner.js").InlinerMathStorage>;
+    readonly dependencies: {
         katex: {
             optimise: boolean;
             transpile: boolean;

package/dist/elements/math/core.js

@@ -1,11 +1,3 @@
-import { defineEruditProseCoreElements } from "../../coreElement.js";
-import { blockMathRegistryItem } from "./block.js";
-import { inlinerMathRegistryItem } from "./inliner.js";
-import { katexDependency } from "./katex.js";
-export default defineEruditProseCoreElements({
-	registryItem: inlinerMathRegistryItem,
-	dependencies: katexDependency
-}, {
-	registryItem: blockMathRegistryItem,
-	dependencies: katexDependency
-});
+import { blockMathCoreElement } from "./block.js";
+import { inlinerMathCoreElement } from "./inliner.js";
+export default [blockMathCoreElement, inlinerMathCoreElement];

package/dist/elements/math/inliner.d.ts

@@ -1,4 +1,4 @@
-import { type TagChildren } from '@jsprose/core';
+import { type RequiredChildren, type Schema } from 'tsprose';
 export type InlinerMathType = 'katex' | 'text';
 interface InlinerMathBase {
     type: InlinerMathType;
@@ -20,45 +20,33 @@ export type InlinerMathStorage = InlinerMathKatex | InlinerMathText;
  * Try to use simple text mode for inline math as it is significantly better for SEO, faster and smaller.
  */
 export declare function tryTextInlinerMath(expression: string): InlinerMathText | undefined;
-export declare const inlinerMathSchema: {
-    name: "inlinerMath";
-    type: "inliner";
+export interface InlinerMathSchema extends Schema {
+    name: 'inlinerMath';
+    type: 'inliner';
     linkable: true;
     Data: string;
     Storage: InlinerMathStorage;
     Children: undefined;
+}
+export declare const inlinerMathSchema: InlinerMathSchema;
+export declare const M: import("../../tag.js").ToEruditTag<InlinerMathSchema, "M", RequiredChildren>;
+export declare const inlinerMathCoreElement: {
+    readonly schema: InlinerMathSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<InlinerMathSchema, "M", RequiredChildren>];
+    readonly createStorage: (element: {
+        schema: InlinerMathSchema;
+        id: string;
+        data: string;
+        storageKey: string;
+        children: undefined;
+        __TSPROSE_proseElement: true;
+    }) => Promise<InlinerMathStorage>;
+    readonly dependencies: {
+        katex: {
+            optimise: boolean;
+            transpile: boolean;
+        };
+    };
 };
-export declare const M: import("@jsprose/core").Tag<"M", {
-    name: "inlinerMath";
-    type: "inliner";
-    linkable: true;
-    Data: string;
-    Storage: InlinerMathStorage;
-    Children: undefined;
-}, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-export declare const inlinerMathRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "inlinerMath";
-    type: "inliner";
-    linkable: true;
-    Data: string;
-    Storage: InlinerMathStorage;
-    Children: undefined;
-}, {
-    M: import("@jsprose/core").Tag<"M", {
-        name: "inlinerMath";
-        type: "inliner";
-        linkable: true;
-        Data: string;
-        Storage: InlinerMathStorage;
-        Children: undefined;
-    }, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-}, (element: import("@jsprose/core").ProseElement<{
-    name: "inlinerMath";
-    type: "inliner";
-    linkable: true;
-    Data: string;
-    Storage: InlinerMathStorage;
-    Children: undefined;
-}>) => Promise<InlinerMathStorage>>;
 export declare function createInlinerMathStorage(katex: string): Promise<InlinerMathStorage>;
 export {};

package/dist/elements/math/inliner.js

@@ -1,6 +1,8 @@
-import { defineRegistryItem, defineSchema, ensureTagChild, ProseError, textSchema } from "@jsprose/core";
+import { defineSchema, ensureTagChildren, textSchema } from "tsprose";
 import { defineEruditTag } from "../../tag.js";
-import { latexToHtml, normalizeKatex } from "./katex.js";
+import { katexDependency, latexToHtml, normalizeKatex } from "./katex.js";
+import { EruditProseError } from "../../error.js";
+import { defineProseCoreElement } from "../../coreElement.js";
 /**
 * Apply typographical replacements to improve math rendering
 */
@@ -40,32 +42,28 @@ export function tryTextInlinerMath(expression) {
 	}
 	return undefined;
 }
-//
-//
-//
 export const inlinerMathSchema = defineSchema({
 	name: "inlinerMath",
 	type: "inliner",
 	linkable: true
-})();
+});
 export const M = defineEruditTag({
 	tagName: "M",
 	schema: inlinerMathSchema
 })(({ element, tagName, children }) => {
-	ensureTagChild(tagName, children, textSchema);
+	ensureTagChildren(tagName, children, textSchema);
 	const katex = normalizeKatex(children[0].data);
 	if (!katex) {
-		throw new ProseError(`<${tagName}> tag must contain non-empty KaTeX math expression.`);
+		throw new EruditProseError(`<${tagName}> tag must contain non-empty KaTeX math expression.`);
 	}
 	element.data = katex;
 	element.storageKey = `$ ${katex} $`;
 });
-export const inlinerMathRegistryItem = defineRegistryItem({
+export const inlinerMathCoreElement = defineProseCoreElement({
 	schema: inlinerMathSchema,
 	tags: [M],
-	async createStorage(element) {
-		return createInlinerMathStorage(element.data);
-	}
+	createStorage: async (element) => createInlinerMathStorage(element.data),
+	dependencies: katexDependency
 });
 export async function createInlinerMathStorage(katex) {
 	const tokens = tryTextInlinerMath(katex);

package/dist/elements/paragraph/Paragraph.vue

@@ -1,11 +1,11 @@
 <script setup lang="ts">
-import type { ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 
-import type { paragraphSchema } from './core.js';
+import type { ParagraphSchema } from './core.js';
 import Block from '../../app/shared/block/Block.vue';
 import Render from '../../app/shared/Render.vue';
 
-defineProps<{ element: ProseElement<typeof paragraphSchema> }>();
+defineProps<{ element: ToProseElement<ParagraphSchema> }>();
 </script>
 
 <template>

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

@@ -1,9 +1,2 @@
-declare const _default: import("../../app/appElement.js").AppElement<{
-    name: "paragraph";
-    type: "block";
-    linkable: true;
-    Data: import("./core.js").ParagraphData;
-    Storage: undefined;
-    Children: import("@jsprose/core").InlinerSchema[];
-}>;
+declare const _default: import("../../app/appElement.js").ProseAppElement<import("./core.js").ParagraphSchema>;
 export default _default;

package/dist/elements/paragraph/app.js

@@ -1,6 +1,6 @@
-import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { defineProseAppElement } from "../../app/appElement.js";
 import { paragraphSchema } from "./core.js";
-export default defineEruditProseAppElement({
+export default defineProseAppElement({
 	schema: paragraphSchema,
 	component: () => import("./Paragraph.vue"),
 	languages: {

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

@@ -1,67 +1,26 @@
-import { type InlinerSchema, type TagChildren } from '@jsprose/core';
-export declare const paragraphSchema: {
-    name: "paragraph";
-    type: "block";
+import { type InlinerSchema, type Schema } from 'tsprose';
+export interface ParagraphSchema extends Schema {
+    name: 'paragraph';
+    type: 'block';
     linkable: true;
     Data: ParagraphData;
     Storage: undefined;
     Children: InlinerSchema[];
-};
+}
+export declare const paragraphSchema: ParagraphSchema;
 export type ParagraphData = undefined | {
     center?: boolean;
     serif?: boolean;
 };
-export declare const P: import("@jsprose/core").Tag<"P", {
-    name: "paragraph";
-    type: "block";
-    linkable: true;
-    Data: ParagraphData;
-    Storage: undefined;
-    Children: InlinerSchema[];
-}, {
+export declare const P: import("../../tag.js").ToEruditTag<ParagraphSchema, "P", {
     center?: true;
     serif?: true;
-} & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-export declare const paragraphRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "paragraph";
-    type: "block";
-    linkable: true;
-    Data: ParagraphData;
-    Storage: undefined;
-    Children: InlinerSchema[];
-}, {
-    P: import("@jsprose/core").Tag<"P", {
-        name: "paragraph";
-        type: "block";
-        linkable: true;
-        Data: ParagraphData;
-        Storage: undefined;
-        Children: InlinerSchema[];
-    }, {
+}>;
+declare const _default: {
+    readonly schema: ParagraphSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<ParagraphSchema, "P", {
         center?: true;
         serif?: true;
-    } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-}, undefined>;
-declare const _default: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "paragraph";
-        type: "block";
-        linkable: true;
-        Data: ParagraphData;
-        Storage: undefined;
-        Children: InlinerSchema[];
-    }, {
-        P: import("@jsprose/core").Tag<"P", {
-            name: "paragraph";
-            type: "block";
-            linkable: true;
-            Data: ParagraphData;
-            Storage: undefined;
-            Children: InlinerSchema[];
-        }, {
-            center?: true;
-            serif?: true;
-        } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-    }, undefined>;
+    }>];
 };
 export default _default;