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

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

@@ -1,2 +1,2 @@
 import type { VideoStorage } from './core.js';
-export declare function createVideoStorage(projectAbsPath: string, projectBaseUrl: string, videoAbsoluteSrc: string): VideoStorage;
+export declare function createVideoStorage(projectAbsPath: string, projectBaseUrl: string, videoRelSrc: string): VideoStorage;

package/dist/elements/video/storage.js

@@ -1,5 +1,4 @@
-import { projectRelFilePath } from "../../shared/filePath.js";
-export function createVideoStorage(projectAbsPath, projectBaseUrl, videoAbsoluteSrc) {
-	const resolvedSrc = projectBaseUrl + "file/" + projectRelFilePath(projectAbsPath, videoAbsoluteSrc);
+export function createVideoStorage(projectAbsPath, projectBaseUrl, videoRelSrc) {
+	const resolvedSrc = projectBaseUrl + "file/" + videoRelSrc;
 	return { resolvedSrc };
 }

package/dist/error.d.ts

@@ -0,0 +1,3 @@
+export declare class EruditProseError extends Error {
+    constructor(message: string);
+}

package/dist/error.js

@@ -0,0 +1,6 @@
+export class EruditProseError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EruditProseError";
+	}
+}

package/dist/include.d.ts

@@ -1,6 +1,6 @@
-import { type AnySchema, type AnyUnique, type RawElement } from '@jsprose/core';
+import { type RawElement, type Unique } from 'tsprose';
 export declare function Include(props: {
-    children: AnyUnique | RawElement<AnySchema>;
+    children: Unique | RawElement;
     toc?: true | string;
-}): RawElement<AnySchema>;
-export declare function isIncludedRawElement(rawElement: RawElement<AnySchema>): boolean;
+}): RawElement;
+export declare function isIncludedRawElement(rawElement: RawElement): boolean;

package/dist/include.js

@@ -1,6 +1,6 @@
-import { isUnique } from "@jsprose/core";
+import { isUnique } from "tsprose";
 import { finalizeToc } from "./toc.js";
-const includedKey = "__ERUDIT_included";
+const ERUDIT_INCLUDE_FLAG = "__ERUDIT_included";
 export function Include(props) {
 	const rawElement = isUnique(props.children) ? props.children.rawElement : props.children;
 	function augmentRawElement(element) {
@@ -8,15 +8,9 @@ export function Include(props) {
 		if (isRoot) {
 			if (props.toc) {
 				if (props.toc === true) {
-					element.toc = finalizeToc({
-						props: { toc: props.toc },
-						element
-					});
+					finalizeToc(element, true);
 				} else {
-					element.toc = {
-						add: true,
-						title: props.toc
-					};
+					finalizeToc(element, props.toc);
 				}
 			} else {
 				delete element.toc;
@@ -26,7 +20,7 @@ export function Include(props) {
 		}
 		delete element.snippet;
 		delete element.uniqueName;
-		element[includedKey] = true;
+		element[ERUDIT_INCLUDE_FLAG] = true;
 		if (element.children) {
 			for (const child of element.children) {
 				augmentRawElement(child);
@@ -37,5 +31,5 @@ export function Include(props) {
 	return rawElement;
 }
 export function isIncludedRawElement(rawElement) {
-	return rawElement[includedKey] === true;
+	return rawElement[ERUDIT_INCLUDE_FLAG] === true;
 }

package/dist/index.d.ts

@@ -1,15 +1,15 @@
+export * from './rawToProse/index.js';
+export * from './rawToProse/hook.js';
+export * from './shared/filePath.js';
+export * from './shared/invert.js';
+export * from './shared/paragraphWrap.js';
+export * from './shared/photoswipe.js';
+export * from './slugify/index.js';
+export * from './utils/case.js';
 export * from './coreElement.js';
+export * from './error.js';
+export * from './include.js';
 export * from './rawElement.js';
-export * from './resolve.js';
-export * from './tag.js';
 export * from './snippet.js';
+export * from './tag.js';
 export * from './toc.js';
-export * from './title.js';
-export * from './resolveStep.js';
-export * from './include.js';
-export * from './slugify/index.js';
-export * from './utils/docs.js';
-export * from './utils/case.js';
-export * from './shared/filePath.js';
-export * from './shared/invert.js';
-export * from './shared/photoswipe.js';

package/dist/index.js

@@ -1,15 +1,15 @@
+export * from "./rawToProse/index.js";
+export * from "./rawToProse/hook.js";
+export * from "./shared/filePath.js";
+export * from "./shared/invert.js";
+export * from "./shared/paragraphWrap.js";
+export * from "./shared/photoswipe.js";
+export * from "./slugify/index.js";
+export * from "./utils/case.js";
 export * from "./coreElement.js";
+export * from "./error.js";
+export * from "./include.js";
 export * from "./rawElement.js";
-export * from "./resolve.js";
-export * from "./tag.js";
 export * from "./snippet.js";
+export * from "./tag.js";
 export * from "./toc.js";
-export * from "./title.js";
-export * from "./resolveStep.js";
-export * from "./include.js";
-export * from "./slugify/index.js";
-export * from "./utils/docs.js";
-export * from "./utils/case.js";
-export * from "./shared/filePath.js";
-export * from "./shared/invert.js";
-export * from "./shared/photoswipe.js";

package/dist/rawElement.d.ts

@@ -1,6 +1,9 @@
-import type { AnySchema, RawElement, schemaKind } from '@jsprose/core';
-import type { ObjRawElementSnippet } from './snippet.js';
-import type { ObjRawElementToc } from './toc.js';
-import type { ObjRawElementTitle } from './title.js';
-export type EruditRawElement<TSchema extends AnySchema, TTagName extends string = string> = RawElement<TSchema, TTagName> & ObjRawElementSnippet & ObjRawElementToc & ObjRawElementTitle;
-export declare function asEruditRaw<TSchema extends AnySchema, TRawElement extends RawElement<TSchema>>(rawElement: TRawElement): EruditRawElement<TRawElement[typeof schemaKind], TRawElement['tagName']>;
+import { type RawElement, type Schema, type ToRawElement } from 'tsprose';
+import type { TocRawElementProp } from './toc.js';
+import type { SnippetRawElementProp } from './snippet.js';
+export type ToEruditRawElement<TSchema extends Schema, TagName extends string = string> = ToRawElement<TSchema, TagName> & SnippetRawElementProp & TocRawElementProp & {
+    title?: string;
+};
+export type EruditRawElement = ToEruditRawElement<Schema>;
+export declare function asEruditRaw<TSchema extends Schema>(rawElement: RawElement): ToEruditRawElement<TSchema>;
+export declare function isEruditRawElement<TSchema extends Schema>(element: any, schema?: TSchema): element is ToEruditRawElement<TSchema>;

package/dist/rawElement.js

@@ -1,3 +1,7 @@
+import { isRawElement } from "tsprose";
 export function asEruditRaw(rawElement) {
 	return rawElement;
 }
+export function isEruditRawElement(element, schema) {
+	return isRawElement(element, schema);
+}

package/dist/rawToProse/countSchemas.d.ts

@@ -0,0 +1 @@
+export declare const countSchemasHook: import("./hook.js").RawToProseHook;

package/dist/rawToProse/countSchemas.js

@@ -0,0 +1,11 @@
+import { isIncludedRawElement } from "../include.js";
+import { defineRawToProseHook } from "./hook.js";
+export const countSchemasHook = defineRawToProseHook(({ result }) => {
+	return { step({ rawElement }) {
+		if (isIncludedRawElement(rawElement)) {
+			return;
+		}
+		const schemaName = rawElement.schema.name;
+		result.schemaCounts[schemaName] = (result.schemaCounts[schemaName] || 0) + 1;
+	} };
+});

package/dist/rawToProse/hook.d.ts

@@ -0,0 +1,39 @@
+import type { ProseElement, Schema } from 'tsprose';
+import type { EruditRawElement, ToEruditRawElement } from '../rawElement.js';
+import type { EruditRawToProseTask, EruditRawToProseResult } from './index.js';
+export type RawToProseHookReturn = void | {
+    step?: (elements: {
+        rawElement: EruditRawElement;
+        proseElement: ProseElement;
+    }) => void | Promise<void>;
+    finally?: () => void | Promise<void>;
+};
+export type RawToProseHook = (args: {
+    task: EruditRawToProseTask;
+    result: EruditRawToProseResult;
+}) => RawToProseHookReturn | Promise<RawToProseHookReturn>;
+export declare function defineRawToProseHook(hook: RawToProseHook): RawToProseHook;
+export type RawToProseSchemaHookReturn<TSchema extends Schema = Schema> = void | (({
+    anyStep(elements: {
+        rawElement: EruditRawElement;
+        proseElement: ProseElement;
+    }): void | Promise<void>;
+} | {
+    anyStep?: undefined;
+}) & ({
+    matchStep(elements: {
+        rawElement: ToEruditRawElement<TSchema>;
+        proseElement: ProseElement;
+    }): void | Promise<void>;
+} | {
+    matchStep?: undefined;
+}) & {
+    finally?: () => void | Promise<void>;
+});
+export type RawToProseSchemaHook<TSchema extends Schema = Schema> = (args: {
+    task: EruditRawToProseTask;
+    result: EruditRawToProseResult;
+}) => RawToProseSchemaHookReturn<TSchema> | Promise<RawToProseSchemaHookReturn<TSchema>>;
+export type RawToProseHooks = RawToProseHook[];
+export type RawToProseSchemaHooks = Map<Schema, RawToProseSchemaHook>;
+export declare function defineRawToProseSchemaHook<TSchema extends Schema>(hook: RawToProseSchemaHook<TSchema>): RawToProseSchemaHook<TSchema>;

package/dist/rawToProse/hook.js

@@ -0,0 +1,6 @@
+export function defineRawToProseHook(hook) {
+	return hook;
+}
+export function defineRawToProseSchemaHook(hook) {
+	return hook;
+}

package/dist/rawToProse/index.d.ts

@@ -0,0 +1,34 @@
+import { type IdMaker, type RawToProseResult, type Schema } from 'tsprose';
+import type { EruditLanguageCode } from '@erudit-js/core/eruditConfig/language';
+import type { EruditRawElement } from '../rawElement.js';
+import { type ResolvedSnippet } from '../snippet.js';
+import type { RawToProseHooks, RawToProseSchemaHooks } from './hook.js';
+import { type ResolvedTocItem } from '../toc.js';
+import { type SlugifyCreator } from '../slugify/index.js';
+import { type ContentLinks } from '../elements/link/hook.js';
+export type EruditRawToProseTask = {
+    rawProse: EruditRawElement;
+    language?: EruditLanguageCode;
+    snippets?: {
+        enabled: boolean;
+    };
+    toc?: {
+        enabled: boolean;
+        /** Try to add elements with provided schemas. They must have title and not be manually excluded from TOC. */
+        addSchemas?: Schema[];
+    };
+    hooks?: RawToProseHooks;
+    schemaHooks?: RawToProseSchemaHooks;
+    idMaker?: IdMaker;
+    createSlugify?: SlugifyCreator;
+};
+export interface EruditRawToProseResult extends RawToProseResult {
+    toc: ResolvedTocItem[];
+    snippets: ResolvedSnippet[];
+    files: Set<string>;
+    problemScripts: Set<string>;
+    contentLinks: ContentLinks;
+    schemaCounts: Record<string, number>;
+    uniqueTitles: Record<string, string>;
+}
+export declare function eruditRawToProse(task: EruditRawToProseTask): Promise<EruditRawToProseResult>;

package/dist/rawToProse/index.js

@@ -0,0 +1,92 @@
+import { isRawElement, rawToProse } from "tsprose";
+import { snippetHook } from "../snippet.js";
+import { tocHook } from "../toc.js";
+import { createDefaultSlugify } from "../slugify/index.js";
+import { problemScriptHook } from "../elements/problem/hook.js";
+import { linkHook } from "../elements/link/hook.js";
+import { countSchemasHook } from "./countSchemas.js";
+import { uniqueTitlesHook } from "./uniqueTitles.js";
+export async function eruditRawToProse(task) {
+	const { rawProse, hooks, schemaHooks } = task;
+	const result = {
+		prose: undefined,
+		uniques: {},
+		takenIds: new Map(),
+		toc: [],
+		snippets: [],
+		files: new Set(),
+		problemScripts: new Set(),
+		contentLinks: new Map(),
+		schemaCounts: {},
+		uniqueTitles: {}
+	};
+	const _hooks = [
+		snippetHook,
+		tocHook,
+		problemScriptHook,
+		linkHook,
+		countSchemasHook,
+		uniqueTitlesHook,
+		...hooks || []
+	];
+	const createdHooks = [];
+	for (const hook of _hooks) {
+		const createdHook = await hook({
+			task,
+			result
+		});
+		if (createdHook) {
+			createdHooks.push(createdHook);
+		}
+	}
+	const createdSchemaHooks = new Map();
+	for (const [schema, hook] of schemaHooks || []) {
+		const createdHook = await hook({
+			task,
+			result
+		});
+		if (createdHook) {
+			createdSchemaHooks.set(schema, createdHook);
+		}
+	}
+	const step = async (elements) => {
+		for (const [schema, schemaHook] of createdSchemaHooks) {
+			if (schemaHook.anyStep) {
+				await schemaHook.anyStep(elements);
+			}
+			if (isRawElement(elements.rawElement, schema)) {
+				if (schemaHook.matchStep) {
+					await schemaHook.matchStep({
+						rawElement: elements.rawElement,
+						proseElement: elements.proseElement
+					});
+				}
+			}
+		}
+		for (const hook of createdHooks) {
+			if (hook.step) {
+				await hook.step(elements);
+			}
+		}
+	};
+	const baseRawToProseResult = await rawToProse({
+		rawProse,
+		step,
+		idMaker: task.idMaker,
+		slugify: task.createSlugify ? await task.createSlugify(task) : await createDefaultSlugify(task)
+	});
+	result.prose = baseRawToProseResult.prose;
+	result.uniques = baseRawToProseResult.uniques;
+	result.takenIds = baseRawToProseResult.takenIds;
+	for (const schemaHook of createdSchemaHooks.values()) {
+		if (schemaHook.finally) {
+			await schemaHook.finally();
+		}
+	}
+	for (const hook of createdHooks) {
+		if (hook.finally) {
+			await hook.finally();
+		}
+	}
+	return result;
+}

package/dist/rawToProse/uniqueTitles.d.ts

@@ -0,0 +1 @@
+export declare const uniqueTitlesHook: import("./hook.js").RawToProseHook;

package/dist/rawToProse/uniqueTitles.js

@@ -0,0 +1,11 @@
+import { defineRawToProseHook } from "./hook.js";
+export const uniqueTitlesHook = defineRawToProseHook(({ result }) => {
+	return { step({ rawElement }) {
+		if (rawElement.uniqueName) {
+			const title = rawElement.title || rawElement.snippet?.title;
+			if (title) {
+				result.uniqueTitles[rawElement.uniqueName] = title;
+			}
+		}
+	} };
+});

package/dist/shared/filePath.js

@@ -1,11 +1,11 @@
-import { ProseError } from "@jsprose/core";
+import { EruditProseError } from "../error.js";
 /**
 * Checks that the given absolute file path is within the given absolute project path.
 * Returns the file path relative to the project path.
 */
 export function projectRelFilePath(projectAbsPath, fileAbsPath) {
 	if (!fileAbsPath.startsWith(projectAbsPath)) {
-		throw new ProseError(`File "${fileAbsPath}" is outside of project "${projectAbsPath}"`);
+		throw new EruditProseError(`File "${fileAbsPath}" is outside of project "${projectAbsPath}"`);
 	}
 	return fileAbsPath.slice(projectAbsPath.length + 1);
 }

package/dist/shared/paragraphWrap.d.ts

@@ -1,3 +1,3 @@
-import { type NormalizedChildren, type RawElement } from '@jsprose/core';
-import type { paragraphSchema } from '../elements/paragraph/core.js';
-export declare function tryParagraphWrap(children: NormalizedChildren): undefined | [RawElement<typeof paragraphSchema>];
+import type { NormalizedChildren, ToRawElement } from 'tsprose';
+import { type ParagraphSchema } from '../elements/paragraph/core.js';
+export declare function paragraphWrap(children: NormalizedChildren): undefined | [ToRawElement<ParagraphSchema>];

package/dist/shared/paragraphWrap.js

@@ -1,15 +1,10 @@
-import { PROSE_REGISTRY } from "@jsprose/core";
-export function tryParagraphWrap(children) {
-	const P = PROSE_REGISTRY.getTag("P");
-	let hasInliners = children?.some((child) => {
-		const schema = PROSE_REGISTRY.getSchema(child.schemaName);
-		return schema.type === "inliner";
-	});
-	if (hasInliners) {
-		return [P({
-			children,
-			__JSPROSE_registryProp: PROSE_REGISTRY
-		})];
+import { P } from "../elements/paragraph/core.js";
+export function paragraphWrap(children) {
+	if (!children) {
+		return undefined;
 	}
+	try {
+		return [P({ children })];
+	} catch {}
 	return undefined;
 }

package/dist/slugify/index.d.ts

@@ -1 +1,3 @@
-export declare function slugify(text: string, language: string): Promise<string | undefined>;
+import type { EruditRawToProseTask } from '../rawToProse/index.js';
+export type SlugifyCreator = (context: EruditRawToProseTask) => Promise<(text: string) => string>;
+export declare const createDefaultSlugify: SlugifyCreator;

package/dist/slugify/index.js

@@ -1,12 +1,11 @@
-export async function slugify(text, language) {
+export const createDefaultSlugify = async (context) => {
 	const slugifiers = {
 		en: async () => await import("./languages/en.js"),
 		ru: async () => await import("./languages/ru.js")
 	};
-	const slugifyModule = language in slugifiers ? await slugifiers[language]() : undefined;
+	const slugifyModule = context.language && context.language in slugifiers ? await slugifiers[context.language]() : undefined;
 	if (slugifyModule) {
-		const slug = slugifyModule.default(text);
-		return slug || undefined;
+		return slugifyModule.default;
 	}
-	return undefined;
-}
+	return (text) => text;
+};

package/dist/slugify/languages/en.js

@@ -1,3 +1,3 @@
 export default (text) => {
-	return text.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+	return text.replace(/(\p{Lu}{2,})(\p{Ll})/gu, "$1-$2").replace(/(\p{Ll})(\p{Lu})/gu, "$1-$2").replace(/(\p{L})(\d)/gu, "$1-$2").replace(/(\d)(\p{L})/gu, "$1-$2").toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 };

package/dist/slugify/languages/ru.js

@@ -34,5 +34,5 @@ export default (text) => {
 		ю: "yu",
 		я: "ya"
 	};
-	return text.toLowerCase().split("").map((char) => cyrillicToLatin[char] !== undefined ? cyrillicToLatin[char] : /[a-z0-9]/.test(char) ? char : "-").join("").replace(/-+/g, "-").replace(/^-|-$/g, "");
+	return text.replace(/(\p{Lu}{2,})(\p{Ll})/gu, "$1-$2").replace(/(\p{Ll})(\p{Lu})/gu, "$1-$2").replace(/(\p{L})(\d)/gu, "$1-$2").replace(/(\d)(\p{L})/gu, "$1-$2").toLowerCase().split("").map((char) => cyrillicToLatin[char] !== undefined ? cyrillicToLatin[char] : /[a-z0-9]/.test(char) ? char : "-").join("").replace(/-+/g, "-").replace(/^-|-$/g, "");
 };

package/dist/snippet.d.ts

@@ -1,56 +1,62 @@
-import { type AnySchema, type ProseElement } from '@jsprose/core';
-import type { EruditProcessTagArgs } from './tag.js';
 import type { EruditRawElement } from './rawElement.js';
-/**
- * Snippet attribute - only contains title and description
- */
-export interface SnippetData {
-    /** General snippet title. Used as fallback value for flags. */
+export declare const NO_SNIPPET_PREFIX = "__ERDUIT_tagNoSnippet";
+export type NoSnippet = {
+    [NO_SNIPPET_PREFIX]: true;
+};
+export interface SnippetTagProp {
+    /** Compact summary of the element and where to show it (search results, preamble, SEO). */
+    snippet?: SnippetRaw;
+}
+export interface SnippetRawElementProp {
+    snippet?: SnippetRaw;
+}
+export interface SnippetRaw {
     title?: string;
-    /** General snippet description. Used as fallback value for flags. */
     description?: string;
-    /**
-     * Show element in search results.
-     */
+    /** Show element in search results. */
     search?: boolean | string | string[] | {
         title?: string;
         description?: string;
         synonyms?: string[];
     };
-    /**
-     * Show element in "Quick Links" sections at start of the page and also in TOC.
-     */
-    quick?: boolean | string | {
+    /** Show element in "Key elements" section of content preamble. */
+    key?: boolean | string | {
         title?: string;
         description?: string;
     };
     /**
-     * When targeting this element with '#' anchor, adjust SEO metadata (like title and description).
-     * Search engines should treat it as a different "page" and therefore show it as a standalone search result.
+     * Set custom page SEO metadata when targeting this element.
+     * Search engines treat it as a different "page" and therefore show it as a standalone search result.
      */
     seo?: boolean | string | {
         title?: string;
         description?: string;
     };
 }
-export type ObjPropSnippet = {
-    /**
-     * Compact summary of the element and where to show it (search, quick links, SEO).
-     */
-    snippet?: SnippetData;
-};
-export type ObjRawElementSnippet = {
-    snippet?: SnippetData;
+export type Snippet = Omit<SnippetRaw, 'title'> & {
+    title: string;
 };
-export declare function finalizeSnippet(processTagArgs: EruditProcessTagArgs): SnippetData | undefined;
+export declare function finalizeSnippet(rawElement: EruditRawElement, snippetTagProp: SnippetTagProp['snippet']): void;
+export declare function normalizeSnippet(snippet: SnippetRaw, ...fallbackTitles: (string | undefined)[]): Snippet;
+export interface SearchSnippet {
+    title: string;
+    description?: string;
+    synonyms?: string[];
+}
+export declare function toSearchSnippet(snippet?: Snippet): SearchSnippet | undefined;
+export interface KeySnippet {
+    title: string;
+    description?: string;
+}
+export declare function toKeySnippet(snippet?: Snippet): KeySnippet | undefined;
+export interface SeoSnippet {
+    title: string;
+    description?: string;
+}
+export declare function toSeoSnippet(snippet?: Snippet): SeoSnippet | undefined;
 export interface ResolvedSnippet {
     schemaName: string;
-    isUnique: boolean;
     elementId: string;
-    snippetData: SnippetData;
+    snippet: Snippet;
 }
-export declare const snippetStep: ({ rawElement, proseElement }: {
-    context: import("./context.js").EruditProseContext;
-    rawElement: EruditRawElement<AnySchema>;
-    proseElement: ProseElement<AnySchema>;
-}) => ResolvedSnippet | undefined;
+export declare const snippetHook: import("./rawToProse/hook.js").RawToProseHook;