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

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

@@ -1,4 +1,4 @@
-import { type AnySchema, type AnyUnique, type AutoUnique, type LinkableTag, type RawElement, type Unique, type WrapSchemas } from '@jsprose/core';
+import { type AutoUnique, type DocumentUniques, type DocumentUniquesTemplate, type LinkableTag, type RawElement, type ToRawElement, type ToUnique, type Unique } from 'tsprose';
 import { type ProblemSeed, ProblemRandom } from './rng.js';
 import { type ProblemContentChild } from './problemContent.js';
 export type CheckFunction = (args: {
@@ -8,24 +8,32 @@ export type CheckFunction = (args: {
 }) => boolean;
 export declare function insertProblemScriptId(scriptSrc: string, code: string): string;
 export interface ProblemScriptDefinition {
-    uniques?: Record<string, LinkableTag>;
+    uniques?: DocumentUniquesTemplate;
     isGenerator?: boolean;
 }
-export declare function defineProblemScript<const TDefinition extends ProblemScriptDefinition>(scriptSrcOrDefinition?: string | TDefinition, maybeDefinition?: TDefinition): (problemContentFn: (args: (TDefinition["uniques"] extends Record<string, LinkableTag> ? {
-    uniques: { [K in keyof NonNullable<TDefinition["uniques"]>]: Unique<NonNullable<TDefinition["uniques"]>[K]>; };
-} : {}) & (TDefinition["isGenerator"] extends true ? {
+type ProblemContentFnArgs<TDef extends ProblemScriptDefinition> = (TDef['uniques'] extends DocumentUniquesTemplate ? {
+    uniques: DocumentUniques<TDef['uniques']>;
+} : {}) & (TDef['isGenerator'] extends true ? {
     initial: boolean;
     random: ProblemRandom;
-} : {})) => RawElement<AnySchema> | {
-    problemContent: RawElement<AnySchema>;
+} : {});
+type ProblemContentFn<TDef extends ProblemScriptDefinition> = (args: ProblemContentFnArgs<TDef>) => RawElement | {
+    problemContent: RawElement;
     check?: CheckFunction;
-}) => (...args: TDefinition["uniques"] extends Record<string, LinkableTag> ? [uniquesMapping: (() => AutoUnique) | { [K in keyof NonNullable<TDefinition["uniques"]>]: Unique<NonNullable<TDefinition["uniques"]>[K]> | (() => AutoUnique); }] : []) => ProblemScriptInstance;
+};
+type ProblemScriptInstanceCreator<TDef extends ProblemScriptDefinition> = TDef['uniques'] extends DocumentUniquesTemplate ? (uniquesMapping: (() => AutoUnique) | {
+    [K in keyof TDef['uniques']]: ToUnique<TDef['uniques'][K] & LinkableTag> | (() => AutoUnique);
+}) => ProblemScriptInstance : () => ProblemScriptInstance;
+export declare function defineProblemScript(): (contentFn: ProblemContentFn<{}>) => ProblemScriptInstanceCreator<{}>;
+export declare function defineProblemScript<const TDef extends ProblemScriptDefinition>(definition: TDef): (contentFn: ProblemContentFn<TDef>) => ProblemScriptInstanceCreator<TDef>;
+export declare function defineProblemScript<const TDef extends ProblemScriptDefinition>(scriptSrc: string, definition?: TDef): (contentFn: ProblemContentFn<TDef>) => ProblemScriptInstanceCreator<TDef>;
 export interface ProblemScriptInstance {
     scriptSrc: string;
-    uniques: Record<string, AnyUnique>;
+    uniques: Record<string, Unique>;
     isGenerator: boolean;
     generate: (seed?: ProblemSeed) => {
-        problemContent: WrapSchemas<'raw-prose', ProblemContentChild>[];
+        problemContent: ToRawElement<ProblemContentChild>[];
         check?: CheckFunction;
     };
 }
+export {};

package/dist/elements/problem/problemScript.js

@@ -1,37 +1,30 @@
-import { isRawElement, ProseError } from "@jsprose/core";
+import { injectDocumentId, isRawElement } from "tsprose";
 import { DEFAULT_SEED, ProblemRandom } from "./rng.js";
 import { validateProblemContent } from "./problemContent.js";
+import { EruditProseError } from "../../error.js";
 //
 // Problem Script Src
 //
 export function insertProblemScriptId(scriptSrc, code) {
-	// Match: export default defineProblemScript(...)
-	return code.replace(/\bdefineProblemScript\(([\s\S]*?)\)/g, (fullMatch, argsContent) => {
-		const trimmed = argsContent.trim();
-		// If the first argument already looks like a string literal, skip.
-		if (/^['"`]/.test(trimmed)) {
-			return fullMatch;
-		}
-		const needsNoSpace = /^\s*\n/.test(argsContent);
-		const comma = needsNoSpace ? "," : ", ";
-		const newArgs = `'${scriptSrc}'${comma}${argsContent}`;
-		return `defineProblemScript(${newArgs})`;
-	});
+	return injectDocumentId(scriptSrc, code, "defineProblemScript");
 }
+// -- Implementation --
 export function defineProblemScript(scriptSrcOrDefinition, maybeDefinition) {
 	let scriptSrc;
 	let definition;
 	if (typeof scriptSrcOrDefinition === "string") {
 		scriptSrc = scriptSrcOrDefinition;
-		definition = maybeDefinition;
+		definition = maybeDefinition ?? {};
 	} else {
-		throw new ProseError(`Problem script requires script ID to be manually specified or inserted at transform time!`);
+		throw new EruditProseError(`Problem script requires script ID to be manually specified or inserted at transform time!`);
 	}
 	function defineProblemContent(problemContentFn) {
-		function createProblemScriptInstance(...args) {
+		function createInstance(uniquesMapping) {
 			const finalizedUniques = {};
 			if (definition.uniques) {
-				const uniquesMapping = args[0];
+				if (!uniquesMapping) {
+					throw new EruditProseError(`Problem script with uniques requires a uniques mapping!`);
+				}
 				if (typeof uniquesMapping === "function") {
 					for (const key in definition.uniques) {
 						finalizedUniques[key] = uniquesMapping();
@@ -43,10 +36,6 @@ export function defineProblemScript(scriptSrcOrDefinition, maybeDefinition) {
 							finalizedUniques[key] = mapping();
 						} else {
 							finalizedUniques[key] = mapping;
-							// @ts-expect-error
-							delete finalizedUniques[key].rawElement;
-							// @ts-expect-error
-							delete finalizedUniques[key].tag;
 						}
 					}
 				}
@@ -55,25 +44,25 @@ export function defineProblemScript(scriptSrcOrDefinition, maybeDefinition) {
 				scriptSrc,
 				uniques: finalizedUniques,
 				isGenerator: definition.isGenerator ?? false,
-				generate: (seed) => {
+				generate(seed) {
 					const finalizedSeed = seed ?? DEFAULT_SEED;
-					const problemContentResult = problemContentFn({
+					const result = problemContentFn({
 						uniques: finalizedUniques,
 						...definition.isGenerator ? {
 							initial: finalizedSeed === DEFAULT_SEED,
 							random: new ProblemRandom(finalizedSeed)
 						} : {}
 					});
-					const problemContent = isRawElement(problemContentResult) ? problemContentResult : problemContentResult.problemContent;
+					const problemContent = isRawElement(result) ? result : result.problemContent;
 					validateProblemContent("[Problem Script]", problemContent.children);
 					return {
 						problemContent: problemContent.children,
-						check: !isRawElement(problemContentResult) ? problemContentResult.check : undefined
+						check: !isRawElement(result) ? result.check : undefined
 					};
 				}
 			};
 		}
-		return createProblemScriptInstance;
+		return createInstance;
 	}
 	return defineProblemContent;
 }

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

@@ -1,212 +1,53 @@
-import { type AnyUnique, type BlockSchema, type TagChildren } from '@jsprose/core';
+import { type BlockSchema, type Schema, type Unique } from 'tsprose';
 import { type ProblemContentChild } from './problemContent.js';
-import { type ProblemInfo } from './shared.js';
+import { type ProblemInfo, type ProblemInfoProps } from './shared.js';
 import { type ProblemScriptStorage } from './storage.js';
 import { type ProblemScriptInstance } from './problemScript.js';
-export interface SubProblemData {
-    label?: string;
-    scriptUniques?: Record<string, AnyUnique>;
-}
-export declare const subProblemSchema: {
-    name: "subProblem";
-    type: "block";
-    linkable: false;
-    Data: SubProblemData;
-    Storage: ProblemScriptStorage;
-    Children: ProblemContentChild[];
-};
-export declare const SubProblem: import("@jsprose/core").Tag<"SubProblem", {
-    name: "subProblem";
-    type: "block";
+export interface SubProblemSchema extends Schema {
+    name: 'subProblem';
+    type: 'block';
     linkable: false;
     Data: SubProblemData;
     Storage: ProblemScriptStorage;
     Children: ProblemContentChild[];
-}, ({
+}
+export interface SubProblemData {
     label?: string;
-} & {
+    scriptUniques?: Record<string, Unique>;
+}
+export declare const subProblemSchema: SubProblemSchema;
+export declare const SubProblem: import("../../tag.js").ToEruditTag<SubProblemSchema, "SubProblem", {
+    label?: string;
+} & ({
     children: {};
     script?: undefined;
-}) | ({
-    label?: string;
-} & {
+} | {
     script: ProblemScriptInstance;
     children?: undefined;
 })>;
-export declare const subProblemRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "subProblem";
-    type: "block";
-    linkable: false;
-    Data: SubProblemData;
-    Storage: ProblemScriptStorage;
-    Children: ProblemContentChild[];
-}, {
-    SubProblem: import("@jsprose/core").Tag<"SubProblem", {
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: SubProblemData;
-        Storage: ProblemScriptStorage;
-        Children: ProblemContentChild[];
-    }, ({
+export declare const subProblemCoreElement: {
+    readonly schema: SubProblemSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<SubProblemSchema, "SubProblem", {
         label?: string;
-    } & {
+    } & ({
         children: {};
         script?: undefined;
-    }) | ({
-        label?: string;
-    } & {
+    } | {
         script: ProblemScriptInstance;
         children?: undefined;
-    })>;
-}, undefined>;
-export declare const subProblemCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: SubProblemData;
-        Storage: ProblemScriptStorage;
-        Children: ProblemContentChild[];
-    }, {
-        SubProblem: import("@jsprose/core").Tag<"SubProblem", {
-            name: "subProblem";
-            type: "block";
-            linkable: false;
-            Data: SubProblemData;
-            Storage: ProblemScriptStorage;
-            Children: ProblemContentChild[];
-        }, ({
-            label?: string;
-        } & {
-            children: {};
-            script?: undefined;
-        }) | ({
-            label?: string;
-        } & {
-            script: ProblemScriptInstance;
-            children?: undefined;
-        })>;
-    }, undefined>;
-};
-export declare const problemsSchema: {
-    name: "problems";
-    type: "block";
-    linkable: true;
-    Data: ProblemInfo;
-    Storage: undefined;
-    Children: (BlockSchema | {
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: SubProblemData;
-        Storage: ProblemScriptStorage;
-        Children: ProblemContentChild[];
-    })[];
+    })>];
 };
-export declare const Problems: import("@jsprose/core").Tag<"Problems", {
-    name: "problems";
-    type: "block";
+export interface ProblemsSchema extends Schema {
+    name: 'problems';
+    type: 'block';
     linkable: true;
     Data: ProblemInfo;
     Storage: undefined;
-    Children: (BlockSchema | {
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: SubProblemData;
-        Storage: ProblemScriptStorage;
-        Children: ProblemContentChild[];
-    })[];
-}, {
-    title: string;
-    level: import("./shared.js").ProblemLevel;
-    attributes?: (import("./shared.js").ProblemAttribute | import("./shared.js").ProblemCustomAttribute)[];
-} & {
-    pretty?: true | undefined;
-    applied?: true | undefined;
-    method?: true | undefined;
-    inter?: true | undefined;
-} & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-export declare const problemsRegistryItem: import("@jsprose/core").RegistryItem<{
-    name: "problems";
-    type: "block";
-    linkable: true;
-    Data: ProblemInfo;
-    Storage: undefined;
-    Children: (BlockSchema | {
-        name: "subProblem";
-        type: "block";
-        linkable: false;
-        Data: SubProblemData;
-        Storage: ProblemScriptStorage;
-        Children: ProblemContentChild[];
-    })[];
-}, {
-    Problems: import("@jsprose/core").Tag<"Problems", {
-        name: "problems";
-        type: "block";
-        linkable: true;
-        Data: ProblemInfo;
-        Storage: undefined;
-        Children: (BlockSchema | {
-            name: "subProblem";
-            type: "block";
-            linkable: false;
-            Data: SubProblemData;
-            Storage: ProblemScriptStorage;
-            Children: ProblemContentChild[];
-        })[];
-    }, {
-        title: string;
-        level: import("./shared.js").ProblemLevel;
-        attributes?: (import("./shared.js").ProblemAttribute | import("./shared.js").ProblemCustomAttribute)[];
-    } & {
-        pretty?: true | undefined;
-        applied?: true | undefined;
-        method?: true | undefined;
-        inter?: true | undefined;
-    } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-}, undefined>;
+    Children: (SubProblemSchema | BlockSchema)[];
+}
+export declare const problemsSchema: ProblemsSchema;
+export declare const Problems: import("../../tag.js").ToEruditTag<ProblemsSchema, "Problems", ProblemInfoProps>;
 export declare const problemsCoreElement: {
-    registryItem: import("@jsprose/core").RegistryItem<{
-        name: "problems";
-        type: "block";
-        linkable: true;
-        Data: ProblemInfo;
-        Storage: undefined;
-        Children: (BlockSchema | {
-            name: "subProblem";
-            type: "block";
-            linkable: false;
-            Data: SubProblemData;
-            Storage: ProblemScriptStorage;
-            Children: ProblemContentChild[];
-        })[];
-    }, {
-        Problems: import("@jsprose/core").Tag<"Problems", {
-            name: "problems";
-            type: "block";
-            linkable: true;
-            Data: ProblemInfo;
-            Storage: undefined;
-            Children: (BlockSchema | {
-                name: "subProblem";
-                type: "block";
-                linkable: false;
-                Data: SubProblemData;
-                Storage: ProblemScriptStorage;
-                Children: ProblemContentChild[];
-            })[];
-        }, {
-            title: string;
-            level: import("./shared.js").ProblemLevel;
-            attributes?: (import("./shared.js").ProblemAttribute | import("./shared.js").ProblemCustomAttribute)[];
-        } & {
-            pretty?: true | undefined;
-            applied?: true | undefined;
-            method?: true | undefined;
-            inter?: true | undefined;
-        } & TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet>;
-    }, undefined>;
+    readonly schema: ProblemsSchema;
+    readonly tags: [import("../../tag.js").ToEruditTag<ProblemsSchema, "Problems", ProblemInfoProps>];
 };

package/dist/elements/problem/problems.js

@@ -1,15 +1,16 @@
-import { defineRegistryItem, defineSchema, ensureTagBlockChildren, isRawElement, ProseError } from "@jsprose/core";
+import { defineSchema, ensureTagBlockChildren, isRawElement } from "tsprose";
 import { validateProblemContent } from "./problemContent.js";
 import { defineEruditTag } from "../../tag.js";
 import { problemProps2Info } from "./shared.js";
-import { defineEruditProseCoreElement } from "../../coreElement.js";
 import { problemScriptStorageKey } from "./storage.js";
 import "./problemScript.js";
+import { EruditProseError } from "../../error.js";
+import { defineProseCoreElement } from "../../coreElement.js";
 export const subProblemSchema = defineSchema({
 	name: "subProblem",
 	type: "block",
 	linkable: false
-})();
+});
 export const SubProblem = defineEruditTag({
 	tagName: "SubProblem",
 	schema: subProblemSchema
@@ -20,7 +21,7 @@ export const SubProblem = defineEruditTag({
 		element.data.label = label;
 	}
 	if (props.script && children) {
-		throw new ProseError(`<${tagName}> cannot have both script and children!`);
+		throw new EruditProseError(`<${tagName}> cannot have both script and children!`);
 	}
 	if (props.script) {
 		element.data.scriptUniques = props.script.uniques;
@@ -31,24 +32,20 @@ export const SubProblem = defineEruditTag({
 		element.children = children;
 	}
 });
-export const subProblemRegistryItem = defineRegistryItem({
+export const subProblemCoreElement = defineProseCoreElement({
 	schema: subProblemSchema,
 	tags: [SubProblem]
 });
-export const subProblemCoreElement = defineEruditProseCoreElement({ registryItem: subProblemRegistryItem });
-//
-// Problems
-//
 export const problemsSchema = defineSchema({
 	name: "problems",
 	type: "block",
 	linkable: true
-})();
+});
 export const Problems = defineEruditTag({
 	tagName: "Problems",
 	schema: problemsSchema
-})(({ element, tagName, props, children, registry }) => {
-	ensureTagBlockChildren(tagName, children, registry);
+})(({ element, tagName, props, children }) => {
+	ensureTagBlockChildren(tagName, children);
 	const subProblemChildren = [];
 	const otherChildren = [];
 	for (const child of children) {
@@ -59,15 +56,14 @@ export const Problems = defineEruditTag({
 		}
 	}
 	if (subProblemChildren.length === 0) {
-		throw new ProseError(`<${tagName}> must have at least one <SubProblem> child!`);
+		throw new EruditProseError(`<${tagName}> must have at least one <SubProblem> child!`);
 	}
 	element.children = [...otherChildren, ...subProblemChildren];
 	const problemInfo = problemProps2Info(props);
 	element.data = problemInfo;
 	element.title = problemInfo.title;
 });
-export const problemsRegistryItem = defineRegistryItem({
+export const problemsCoreElement = defineProseCoreElement({
 	schema: problemsSchema,
 	tags: [Problems]
 });
-export const problemsCoreElement = defineEruditProseCoreElement({ registryItem: problemsRegistryItem });

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

@@ -2,4 +2,4 @@ export type ProblemScriptStorage = {
     resolvedScriptSrc: string;
 } | undefined;
 export declare function problemScriptStorageKey(scriptId: string): string;
-export declare function createProblemScriptStorage(projectAbsPath: string, projectBaseUrl: string, scriptSrc: string): ProblemScriptStorage;
+export declare function createProblemScriptStorage(projectAbsPath: string, projectBaseUrl: string, scriptRelSrc: string): ProblemScriptStorage;

package/dist/elements/problem/storage.js

@@ -1,8 +1,7 @@
-import { projectRelFilePath } from "../../shared/filePath.js";
 export function problemScriptStorageKey(scriptId) {
 	return `problemScript:${scriptId}`;
 }
-export function createProblemScriptStorage(projectAbsPath, projectBaseUrl, scriptSrc) {
-	const resolvedSrc = projectBaseUrl + "api/problemScript/" + projectRelFilePath(projectAbsPath, scriptSrc.replace(".tsx", "")) + ".js";
+export function createProblemScriptStorage(projectAbsPath, projectBaseUrl, scriptRelSrc) {
+	const resolvedSrc = projectBaseUrl + "api/problemScript/" + scriptRelSrc.replace(".tsx", "") + ".js";
 	return { resolvedScriptSrc: resolvedSrc };
 }

package/dist/elements/table/Table.vue

@@ -1,15 +1,15 @@
 <script lang="ts" setup>
 import { computed } from 'vue';
-import { isProseElement, type ProseElement } from '@jsprose/core';
+import { isProseElement, type ToProseElement } from 'tsprose';
 
-import type { tableSchema } from './core.js';
+import type { TableSchema } from './core.js';
 import { captionSchema } from '../caption/core.js';
 import Render from '../../app/shared/Render.vue';
 import Block from '../../app/shared/block/Block.vue';
 import Caption from '../caption/Caption.vue';
 
 const { element } = defineProps<{
-  element: ProseElement<typeof tableSchema>;
+  element: ToProseElement<TableSchema>;
 }>();
 
 const caption = computed(() => {

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

@@ -1,30 +1,2 @@
-declare const _default: import("../../app/appElement.js").AppElement<{
-    name: "table";
-    type: "block";
-    linkable: true;
-    Data: undefined;
-    Storage: undefined;
-    Children: ({
-        name: "caption";
-        type: "inliner";
-        linkable: false;
-        Data: import("../caption/core.js").CaptionData | undefined;
-        Storage: undefined;
-        Children: import("@jsprose/core").InlinerSchema[];
-    } | {
-        name: "tableRow";
-        type: "inliner";
-        linkable: false;
-        Data: undefined;
-        Storage: undefined;
-        Children: {
-            name: "tableData";
-            type: "inliner";
-            linkable: false;
-            Data: undefined;
-            Storage: undefined;
-            Children: import("@jsprose/core").InlinerSchema[];
-        }[];
-    })[];
-}>;
+declare const _default: import("../../app/appElement.js").ProseAppElement<import("./core.js").TableSchema>;
 export default _default;

package/dist/elements/table/app.js

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