@erudit-js/prose 3.0.0-dev.25

package/dist/resolve.js

@@ -0,0 +1,99 @@
+import { resolveRawElement } from "@jsprose/core";
+import { snippetStep } from "./snippet.js";
+import { tocItemStep } from "./toc.js";
+import { slugify } from "./slugify/index.js";
+import { imageSrcStep } from "./elements/image/core.js";
+import { videoSrcStep } from "./elements/video/core.js";
+import { calloutIconSrcStep } from "./elements/callout/core.js";
+import { problemScriptStep } from "./elements/problem/step.js";
+import { dependencyStep } from "./elements/link/dependency/core.js";
+export async function resolveEruditRawElement(args) {
+	const { context, rawElement, step } = args;
+	const snippets = [];
+	const tocItems = [];
+	const headingStack = [];
+	const dependencies = new Set();
+	const files = new Set();
+	const problemScripts = new Set();
+	const uniqueTitles = {};
+	const _step = async (args) => {
+		const snippet = snippetStep(args);
+		if (snippet) snippets.push(snippet);
+		const tocItem = tocItemStep(args);
+		if (tocItem) {
+			if (tocItem.type === "heading") {
+				// Pop headings from stack that are same level or deeper
+				while (headingStack.length > 0) {
+					const lastItem = headingStack[headingStack.length - 1];
+					if (lastItem.type === "heading" && lastItem.level >= tocItem.level) {
+						headingStack.pop();
+					} else {
+						break;
+					}
+				}
+				// Add to parent or root
+				if (headingStack.length > 0) {
+					const parent = headingStack[headingStack.length - 1];
+					if (parent.type === "heading") {
+						parent.children.push(tocItem);
+					}
+				} else {
+					tocItems.push(tocItem);
+				}
+				// Push this heading to stack
+				headingStack.push(tocItem);
+			} else {
+				// Non-heading item: add to most recent heading or root
+				if (headingStack.length > 0) {
+					const parent = headingStack[headingStack.length - 1];
+					if (parent.type === "heading") {
+						parent.children.push(tocItem);
+					}
+				} else {
+					tocItems.push(tocItem);
+				}
+			}
+		}
+		const resolvedDependency = dependencyStep(args);
+		if (resolvedDependency) dependencies.add(resolvedDependency);
+		const imageSrc = imageSrcStep(args);
+		if (imageSrc && !files.has(imageSrc)) files.add(imageSrc);
+		const videoSrc = videoSrcStep(args);
+		if (videoSrc && !files.has(videoSrc)) files.add(videoSrc);
+		const calloutIconSrc = calloutIconSrcStep(args);
+		if (calloutIconSrc && !files.has(calloutIconSrc)) files.add(calloutIconSrc);
+		const problemScript = problemScriptStep(args);
+		if (problemScript && !problemScripts.has(problemScript)) problemScripts.add(problemScript);
+		if (args.rawElement.title && args.rawElement.uniqueName) {
+			uniqueTitles[args.rawElement.uniqueName] = args.rawElement.title;
+		}
+		if (step) {
+			await step(args);
+		}
+	};
+	const baseResolveResult = await resolveRawElement({
+		rawElement,
+		linkable: context.linkable,
+		pre: async (rawElement) => {
+			if (rawElement.slug) {
+				rawElement.slug = await slugify(rawElement.slug, context.language);
+			}
+		},
+		step: ({ rawElement, proseElement }) => {
+			_step({
+				context,
+				rawElement,
+				proseElement
+			});
+		}
+	});
+	return {
+		...baseResolveResult,
+		snippets,
+		tocItems,
+		dependencies,
+		files,
+		problemScripts,
+		uniqueTitles
+	};
+}

package/dist/resolveStep.d.ts

@@ -0,0 +1,9 @@
+import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { EruditProseContext } from './context.js';
+import type { EruditRawElement } from './rawElement.js';
+export type ResolveStep<TReturn = undefined> = (args: {
+    context: EruditProseContext;
+    rawElement: EruditRawElement<AnySchema>;
+    proseElement: ProseElement<AnySchema>;
+}) => TReturn | Promise<TReturn>;
+export declare function defineResolveStep<TReturn, TStep extends ResolveStep<TReturn>>(step: TStep): TStep;

package/dist/resolveStep.js

@@ -0,0 +1,3 @@
+export function defineResolveStep(step) {
+	return step;
+}

package/dist/shared/filePath.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks that the given absolute file path is within the given absolute project path.
+ * Returns the file path relative to the project path.
+ */
+export declare function projectRelFilePath(projectAbsPath: string, fileAbsPath: string): string;

package/dist/shared/filePath.js

@@ -0,0 +1,11 @@
+import { ProseError } from "@jsprose/core";
+/**
+* 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}"`);
+	}
+	return fileAbsPath.slice(projectAbsPath.length + 1);
+}

package/dist/shared/invert.d.ts

@@ -0,0 +1 @@
+export type Invert = 'light' | 'dark';

package/dist/shared/invert.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/paragraphWrap.d.ts

@@ -0,0 +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>];

package/dist/shared/paragraphWrap.js

@@ -0,0 +1,15 @@
+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
+		})];
+	}
+	return undefined;
+}

package/dist/shared/photoswipe.d.ts

@@ -0,0 +1,10 @@
+export declare const photoswipeDependency: {
+    photoswipe: {
+        optimize: boolean;
+        transpile: boolean;
+    };
+    'photoswipe/lightbox': {
+        optimize: boolean;
+        transpile: boolean;
+    };
+};

package/dist/shared/photoswipe.js

@@ -0,0 +1,10 @@
+export const photoswipeDependency = {
+	photoswipe: {
+		optimize: true,
+		transpile: true
+	},
+	"photoswipe/lightbox": {
+		optimize: true,
+		transpile: true
+	}
+};

package/dist/slugify/index.d.ts

@@ -0,0 +1 @@
+export declare function slugify(text: string, language: string): Promise<string | undefined>;

package/dist/slugify/index.js

@@ -0,0 +1,12 @@
+export async function slugify(text, language) {
+	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;
+	if (slugifyModule) {
+		const slug = slugifyModule.default(text);
+		return slug || undefined;
+	}
+	return undefined;
+}

package/dist/slugify/languages/en.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (text: string) => string;
+export default _default;

package/dist/slugify/languages/en.js

@@ -0,0 +1,3 @@
+export default (text) => {
+	return text.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+};

package/dist/slugify/languages/ru.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (text: string) => string;
+export default _default;

package/dist/slugify/languages/ru.js

@@ -0,0 +1,38 @@
+export default (text) => {
+	const cyrillicToLatin = {
+		а: "a",
+		б: "b",
+		в: "v",
+		г: "g",
+		д: "d",
+		е: "e",
+		ё: "e",
+		ж: "zh",
+		з: "z",
+		и: "i",
+		й: "y",
+		к: "k",
+		л: "l",
+		м: "m",
+		н: "n",
+		о: "o",
+		п: "p",
+		р: "r",
+		с: "s",
+		т: "t",
+		у: "u",
+		ф: "f",
+		х: "kh",
+		ц: "ts",
+		ч: "ch",
+		ш: "sh",
+		щ: "sch",
+		ъ: "",
+		ы: "y",
+		ь: "",
+		э: "e",
+		ю: "yu",
+		я: "ya"
+	};
+	return text.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

@@ -0,0 +1,66 @@
+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 SnippetProp {
+    title?: string;
+    description?: string;
+}
+export type ObjPropSnippet = {
+    /**
+     * Compact summary of the element with title and description.
+     */
+    snippet?: SnippetProp;
+};
+export type ObjPropSearch = {
+    /**
+     * Show element in search results.
+     * Can be a boolean to enable/disable, or an object with synonyms.
+     */
+    search?: boolean | {
+        synonyms: string[];
+    };
+};
+export type ObjPropQuick = {
+    /**
+     * Show element in "Quick Links" sections at start of the page and also in TOC.
+     */
+    quick?: boolean;
+};
+export type ObjPropSeo = {
+    /**
+     * 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.
+     */
+    seo?: boolean;
+};
+export type ObjRawElementSnippet = {
+    snippet?: SnippetProp;
+    snippetFlags?: {
+        quick?: boolean;
+        search?: boolean | {
+            synonyms: string[];
+        };
+        seo?: boolean;
+    };
+};
+export declare function finalizeSnippet(processTagArgs: EruditProcessTagArgs): SnippetProp | undefined;
+export interface ResolvedSnippet {
+    title: string;
+    description?: string;
+    quick?: boolean;
+    search?: boolean | {
+        synonyms: string[];
+    };
+    seo?: boolean;
+    schemaName: string;
+    isUnique: boolean;
+    elementId: string;
+}
+export declare const snippetStep: ({ rawElement, proseElement }: {
+    context: import("./context.js").EruditProseContext;
+    rawElement: EruditRawElement<AnySchema>;
+    proseElement: ProseElement<AnySchema>;
+}) => ResolvedSnippet | undefined;

package/dist/snippet.js

@@ -0,0 +1,57 @@
+import { ProseError } from "@jsprose/core";
+import { defineResolveStep } from "./resolveStep.js";
+export function finalizeSnippet(processTagArgs) {
+	const quick = processTagArgs.props.quick ?? processTagArgs.element.snippetFlags?.quick;
+	const search = processTagArgs.props.search ?? processTagArgs.element.snippetFlags?.search;
+	let seo = processTagArgs.props.seo ?? processTagArgs.element.snippetFlags?.seo;
+	// If none of the flags are set to true, no snippet is created
+	if (!quick && !search && !seo) {
+		return undefined;
+	}
+	// Enable SEO if either quick or search is enabled unless SEO is explicitly disabled
+	// Check both element defaults and props - if either explicitly disables seo, don't auto-enable
+	const seoExplicitlyDisabled = processTagArgs.element.snippetFlags?.seo === false || processTagArgs.props.seo === false;
+	if (!seoExplicitlyDisabled) {
+		if (quick || search) {
+			seo = true;
+		}
+	}
+	const title = finalizeTitle(processTagArgs);
+	const description = finalizeDescription(processTagArgs);
+	const snippet = { title };
+	if (description) {
+		snippet.description = description;
+	}
+	// Store flags on element for later resolution
+	processTagArgs.element.snippetFlags = {
+		quick,
+		search,
+		seo
+	};
+	return snippet;
+}
+function finalizeTitle(processTagArgs) {
+	const title = processTagArgs.props.snippet?.title?.trim() || processTagArgs.element.snippet?.title?.trim() || processTagArgs.element.title?.trim();
+	if (!title) {
+		throw new ProseError(`Unable to finalize snippet title!`);
+	}
+	return title;
+}
+function finalizeDescription(processTagArgs) {
+	return processTagArgs.props.snippet?.description?.trim() || processTagArgs.element.snippet?.description?.trim();
+}
+export const snippetStep = defineResolveStep(({ rawElement, proseElement }) => {
+	if (rawElement.snippet && proseElement.id && rawElement.snippet.title) {
+		const resolvedSnippet = {
+			title: rawElement.snippet.title,
+			description: rawElement.snippet.description,
+			quick: rawElement.snippetFlags?.quick,
+			search: rawElement.snippetFlags?.search,
+			seo: rawElement.snippetFlags?.seo,
+			schemaName: rawElement.schemaName,
+			isUnique: Boolean(rawElement.uniqueName),
+			elementId: proseElement.id
+		};
+		return resolvedSnippet;
+	}
+});

package/dist/tag.d.ts

@@ -0,0 +1,22 @@
+import { Registry, type AnySchema, type ConfigurableTagProps, type NormalizedChildren, type ProcessTagFunction, type TagDefinition } from '@jsprose/core';
+import type { EruditRawElement } from './rawElement.js';
+import { type ObjPropSnippet, type ObjPropSearch, type ObjPropQuick, type ObjPropSeo } from './snippet.js';
+import { type ObjPropToc } from './toc.js';
+declare const NoTocSymbol: unique symbol;
+declare const NoSnippetSymbol: unique symbol;
+export type NoToc = {
+    readonly [NoTocSymbol]?: never;
+};
+export type NoSnippet = {
+    readonly [NoSnippetSymbol]?: never;
+};
+export type EruditTagProps<TProps extends Record<string, unknown>> = (TProps extends NoToc ? {} : ObjPropToc) & (TProps extends NoSnippet ? {} : ObjPropSnippet & ObjPropSearch & ObjPropQuick & ObjPropSeo);
+export type EruditProcessTagArgs = {
+    tagName: string;
+    element: EruditRawElement<AnySchema>;
+    props: ConfigurableTagProps & ObjPropSnippet & ObjPropToc & ObjPropSearch & ObjPropQuick & ObjPropSeo;
+    children: NormalizedChildren;
+    registry: Registry;
+};
+export declare function defineEruditTag<const TSchema extends AnySchema, const TTagDefinition extends TagDefinition<TSchema>>(definition: TTagDefinition): <const TConfigurableTagProps extends ConfigurableTagProps>(processTag: ProcessTagFunction<TTagDefinition["schema"], TTagDefinition, TConfigurableTagProps & (TTagDefinition["schema"]["linkable"] extends true ? EruditTagProps<TConfigurableTagProps> : {}), EruditRawElement<TTagDefinition["schema"], TTagDefinition["tagName"]>>) => import("@jsprose/core").Tag<TTagDefinition["tagName"], TTagDefinition["schema"], TConfigurableTagProps & (TTagDefinition["schema"]["linkable"] extends true ? EruditTagProps<TConfigurableTagProps> : {})>;
+export {};

package/dist/tag.js

@@ -0,0 +1,20 @@
+import { defineTag, Registry } from "@jsprose/core";
+import { finalizeSnippet } from "./snippet.js";
+import { finalizeToc } from "./toc.js";
+import { finalizeTitle } from "./title.js";
+export function defineEruditTag(definition) {
+	const baseFinalizeTag = defineTag(definition);
+	function eruditFinalizeTag(processTag) {
+		const eruditTag = baseFinalizeTag((args) => {
+			processTag(args);
+			// Use every possibility to get shared title property
+			args.element.title = finalizeTitle(args);
+			args.element.snippet = finalizeSnippet(args);
+			args.element.toc = finalizeToc(args);
+			// Use every possibility to get human-readable slug whether it is set manually or taken from snippet or toc
+			args.element.slug ||= args.element.snippet?.title || args.element.toc?.title;
+		});
+		return eruditTag;
+	}
+	return eruditFinalizeTag;
+}

package/dist/title.d.ts

@@ -0,0 +1,8 @@
+import type { EruditProcessTagArgs } from './tag.js';
+export type ObjRawElementTitle = {
+    /**
+     * Shared element title to be used as fallback value (for example, in snippet or TOC).
+     */
+    title?: string;
+};
+export declare function finalizeTitle(processTagArgs: EruditProcessTagArgs): string | undefined;

package/dist/title.js

@@ -0,0 +1,6 @@
+export function finalizeTitle(processTagArgs) {
+	const elementTitle = processTagArgs.element.title?.trim();
+	const propSnippetTitle = processTagArgs.props.snippet?.title?.trim();
+	const propTocTitle = typeof processTagArgs.props.toc === "string" ? processTagArgs.props.toc.trim() : undefined;
+	return elementTitle || propSnippetTitle || propTocTitle || undefined;
+}

package/dist/toc.d.ts

@@ -0,0 +1,34 @@
+import { type AnySchema, type ProseElement } from '@jsprose/core';
+import type { EruditProcessTagArgs } from './tag.js';
+import type { EruditRawElement } from './rawElement.js';
+export type Toc = {
+    title?: string;
+    add?: boolean;
+};
+export type ObjPropToc = {
+    /** Show element in the table of contents */
+    toc?: boolean | string;
+};
+export type ObjRawElementToc = {
+    toc?: Toc;
+};
+export declare function finalizeToc(processTagArgs: EruditProcessTagArgs): Toc | undefined;
+export type ResolvedTocHeading = {
+    type: 'heading';
+    level: 1 | 2 | 3;
+    title: string;
+    elementId: string;
+    children: ResolvedTocItem[];
+};
+export type ResolvedTocElement = {
+    type: 'element';
+    schemaName: string;
+    title: string;
+    elementId: string;
+};
+export type ResolvedTocItem = ResolvedTocHeading | ResolvedTocElement;
+export declare const tocItemStep: ({ rawElement, proseElement }: {
+    context: import("./context.js").EruditProseContext;
+    rawElement: EruditRawElement<AnySchema>;
+    proseElement: ProseElement<AnySchema>;
+}) => ResolvedTocHeading | ResolvedTocElement | undefined;

package/dist/toc.js

@@ -0,0 +1,52 @@
+import { ProseError } from "@jsprose/core";
+import { headingSchema } from "./elements/heading/core.js";
+import { defineResolveStep } from "./resolveStep.js";
+export function finalizeToc(processTagArgs) {
+	const propToc = processTagArgs.props.toc;
+	if (propToc === false) {
+		return undefined;
+	}
+	if (propToc === true) {
+		const title = finalizeTocTitle(processTagArgs);
+		return { title };
+	}
+	if (typeof propToc === "string") {
+		const manualTocTitle = finalizeTocTitle(processTagArgs);
+		return { title: manualTocTitle };
+	}
+	if (processTagArgs.element.toc) {
+		if (processTagArgs.element.toc.add) {
+			const tocTitle = finalizeTocTitle(processTagArgs);
+			return { title: tocTitle };
+		}
+	}
+}
+function finalizeTocTitle(processTagArgs) {
+	const title = (typeof processTagArgs.props.toc === "string" ? processTagArgs.props.toc.trim() : "") || processTagArgs.element.toc?.title?.trim() || processTagArgs.element.title?.trim();
+	if (title) {
+		return title;
+	}
+	throw new ProseError("Unable to finalize TOC title!");
+}
+export const tocItemStep = defineResolveStep(({ rawElement, proseElement }) => {
+	if (rawElement.toc?.title && proseElement.id) {
+		if (rawElement.schemaName === headingSchema.name) {
+			const tocItem = {
+				type: "heading",
+				level: rawElement.data.level,
+				title: rawElement.toc.title,
+				elementId: proseElement.id,
+				children: []
+			};
+			return tocItem;
+		} else {
+			const tocItem = {
+				type: "element",
+				schemaName: rawElement.schemaName,
+				title: rawElement.toc.title,
+				elementId: proseElement.id
+			};
+			return tocItem;
+		}
+	}
+});

package/dist/utils/case.d.ts

@@ -0,0 +1,4 @@
+export type UppercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : S;
+export declare function uppercaseFirst(str: string): string;
+export type LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;
+export declare function lowercaseFirst(str: string): string;

package/dist/utils/case.js

@@ -0,0 +1,8 @@
+export function uppercaseFirst(str) {
+	if (str.length === 0) return str;
+	return str[0].toUpperCase() + str.slice(1);
+}
+export function lowercaseFirst(str) {
+	if (str.length === 0) return str;
+	return str[0].toLowerCase() + str.slice(1);
+}

package/dist/utils/docs.d.ts

@@ -0,0 +1 @@
+export declare function extractTagDocs(tag: string, docsContent: string): string | undefined;

package/dist/utils/docs.js

@@ -0,0 +1,22 @@
+export function extractTagDocs(tag, docsContent) {
+	const blocks = docsContent.match(/\/\*\*[\s\S]*?\*\//g);
+	if (!blocks) {
+		return;
+	}
+	for (const block of blocks) {
+		// After the JSDoc block, match the following JS statement (e.g., let M, Problem...)
+		const after = docsContent.slice(docsContent.indexOf(block) + block.length);
+		// Match trailing variable declarations after this block
+		// e.g.: let A;   OR   let A, B, C;   OR on multiple lines
+		const declMatch = after.match(/^\s*let\s+([^;]+);/);
+		if (!declMatch) {
+			continue;
+		}
+		// Extract all declared names
+		const names = declMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+		// Found?
+		if (names.includes(tag)) {
+			return block;
+		}
+	}
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+    "type": "module",
+    "name": "@erudit-js/prose",
+    "version": "3.0.0-dev.25",
+    "description": "📝 JSX prose subsystem for Erudit sites",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./app": {
+            "import": "./dist/app/index.js",
+            "types": "./dist/app/index.d.ts"
+        },
+        "./elements/*": {
+            "import": "./dist/elements/*.js",
+            "types": "./dist/elements/*.d.ts"
+        },
+        "./types": "./types.d.ts"
+    },
+    "files": [
+        "dist",
+        "types.d.ts"
+    ],
+    "license": "MIT",
+    "scripts": {
+        "build": "bun run script/build.ts",
+        "dev": "bun run script/dev.ts",
+        "test": "bun vitest run",
+        "prepack": "bun run build"
+    },
+    "dependencies": {
+        "@erudit-js/core": "workspace:3.0.0-dev.25",
+        "@jsprose/core": "link:@jsprose/core",
+        "vue": "latest",
+        "@floating-ui/vue": "^1.1.9",
+        "image-size": "^2.0.2",
+        "katex": "^0.16.25",
+        "mermaid": "^11.12.1",
+        "photoswipe": "^5.4.4"
+    },
+    "devDependencies": {
+        "glob": "11.0.3",
+        "oxc-transform": "0.94.0"
+    }
+}

package/types.d.ts

@@ -0,0 +1,4 @@
+declare module '*?raw' {
+    const content: string;
+    export default content;
+}