@erudit-js/prose 3.0.0-dev.25

package/dist/elements/problem/rng.js

@@ -0,0 +1,76 @@
+/**
+* Static seed not random for SEO reasons.
+* It ensures that initial problem content is always the same on each build, helping search engines to index initial problem content consistently.
+*/
+export const DEFAULT_SEED = "3141592653";
+export function normalizeSeed(seed) {
+	if (typeof seed === "number") return seed;
+	let hash = 0;
+	for (let i = 0; i < seed.length; i++) {
+		hash = (hash << 5) - hash + seed.charCodeAt(i);
+		hash |= 0;
+	}
+	return hash;
+}
+export class Random {
+	_rng;
+	constructor(seed) {
+		const normalizedSeed = normalizeSeed(seed);
+		this._rng = splitmix32(normalizedSeed);
+	}
+	rng() {
+		return this._rng();
+	}
+	boolean() {
+		return this.rng() % 2 === 0;
+	}
+	integer(min, max) {
+		const range = max - min + 1;
+		return this.rng() % range + min;
+	}
+	float(min, max, decimals) {
+		const range = max - min;
+		const randomValue = this.rng() / 4294967295 * range + min;
+		return parseFloat(randomValue.toFixed(decimals));
+	}
+	shuffle(arr) {
+		const shuffled = [...arr];
+		for (let i = shuffled.length - 1; i > 0; i--) {
+			const j = this.rng() % (i + 1);
+			[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+		}
+		return shuffled;
+	}
+	arrayElement(arr) {
+		if (arr.length === 0) return undefined;
+		const index = this.rng() % arr.length;
+		return arr[index];
+	}
+	arrayElements(arr, count, unique = true) {
+		if (arr.length === 0) return [];
+		const result = [];
+		if (unique) {
+			const shuffled = this.shuffle(arr);
+			for (let i = 0; i < count && i < shuffled.length; i++) {
+				result.push(shuffled[i]);
+			}
+		} else {
+			for (let i = 0; i < count; i++) {
+				const index = this.rng() % arr.length;
+				result.push(arr[index]);
+			}
+		}
+		return result;
+	}
+}
+function splitmix32(seed) {
+	return function() {
+		seed |= 0;
+		seed = seed + 2654435769 | 0;
+		let t = seed ^ seed >>> 16;
+		t = Math.imul(t, 569420461);
+		t = t ^ t >>> 15;
+		t = Math.imul(t, 1935289751);
+		return (t = t ^ t >>> 15) >>> 0;
+	};
+}

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

@@ -0,0 +1,28 @@
+export declare const problemLevels: readonly ["example", "easy", "medium", "hard"];
+export type ProblemLevel = (typeof problemLevels)[number];
+export declare function isProblemLevel(value: unknown): value is ProblemLevel;
+export declare const problemAttributes: readonly ["pretty", "applied", "method", "inter"];
+export type ProblemAttribute = (typeof problemAttributes)[number];
+export interface ProblemCustomAttribute {
+    label: string;
+    icon?: string;
+    hint?: string;
+}
+export declare const problemActions: readonly ["hint", "answer", "solution", "note", "check", "generate"];
+export type ProblemAction = (typeof problemActions)[number];
+export declare function isProblemAction(value: unknown): value is ProblemAction;
+export interface ProblemInfo {
+    title: string;
+    level: ProblemLevel;
+    attributes: (ProblemAttribute | ProblemCustomAttribute)[];
+}
+export type ProblemInfoProps = {
+    title: string;
+    level: ProblemLevel;
+    attributes?: (ProblemAttribute | ProblemCustomAttribute)[];
+} & AttributeProps;
+type AttributeProps = {
+    [K in ProblemAttribute]?: true;
+};
+export declare function problemProps2Info(props: ProblemInfoProps): ProblemInfo;
+export {};

package/dist/elements/problem/shared.js

@@ -0,0 +1,42 @@
+//
+// Problem Levels
+//
+export const problemLevels = [
+	"example",
+	"easy",
+	"medium",
+	"hard"
+];
+export function isProblemLevel(value) {
+	return typeof value === "string" && problemLevels.includes(value);
+}
+//
+// Problem Attributes
+//
+export const problemAttributes = [
+	"pretty",
+	"applied",
+	"method",
+	"inter"
+];
+//
+// Problem Actions
+//
+export const problemActions = [
+	"hint",
+	"answer",
+	"solution",
+	"note",
+	"check",
+	"generate"
+];
+export function isProblemAction(value) {
+	return typeof value === "string" && problemActions.includes(value);
+}
+export function problemProps2Info(props) {
+	return {
+		title: props.title,
+		level: props.level,
+		attributes: [...problemAttributes.filter((attr) => props[attr] === true), ...props.attributes ?? []]
+	};
+}

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

@@ -0,0 +1,5 @@
+export declare const problemScriptStep: ({ rawElement }: {
+    context: import("../../context.js").EruditProseContext;
+    rawElement: import("../../rawElement.js").EruditRawElement<import("@jsprose/core").AnySchema>;
+    proseElement: import("@jsprose/core").ProseElement<import("@jsprose/core").AnySchema>;
+}) => string | undefined;

package/dist/elements/problem/step.js

@@ -0,0 +1,13 @@
+import { isRawElement } from "@jsprose/core";
+import { defineResolveStep } from "../../resolveStep.js";
+import { problemSchema } from "./problem.js";
+import { subProblemSchema } from "./problems.js";
+export const problemScriptStep = defineResolveStep(({ rawElement }) => {
+	if (!isRawElement(rawElement, problemSchema) && !isRawElement(rawElement, subProblemSchema)) {
+		return;
+	}
+	const script = rawElement.storageKey?.replace("problemScript:", "");
+	if (script) {
+		return script;
+	}
+});

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

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

package/dist/elements/problem/storage.js

@@ -0,0 +1,8 @@
+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";
+	return { resolvedScriptSrc: resolvedSrc };
+}

package/dist/elements/table/Table.vue

@@ -0,0 +1,104 @@
+<script lang="ts" setup>
+import { computed } from 'vue';
+import { isProseElement, type ProseElement } from '@jsprose/core';
+
+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>;
+}>();
+
+const caption = computed(() => {
+    const maybeCaption = element.children[element.children.length - 1];
+    return isProseElement(maybeCaption, captionSchema)
+        ? maybeCaption
+        : undefined;
+});
+
+const rows = computed(() =>
+    caption.value ? element.children.slice(0, -1) : element.children,
+);
+</script>
+
+<template>
+    <Block :element>
+        <div class="nice-scrollbars overflow-auto">
+            <table
+                :class="[
+                    $style.table,
+                    `text-main-sm bg-bg-main m-auto max-w-full border-separate
+                    border-spacing-[3px] rounded border border-(--tableBorder)
+                    transition-[background,border]`,
+                ]"
+            >
+                <tbody>
+                    <tr
+                        v-for="row in rows"
+                        :key="row.id"
+                        class="transition-[background] odd:bg-(--oddCellBg)
+                            even:bg-(--evenCellBg)"
+                    >
+                        <td
+                            v-for="cell in row.children"
+                            :key="cell.id"
+                            class="py-small px-normal rounded"
+                        >
+                            <Render
+                                v-for="inliner of cell.children"
+                                :key="inliner.id"
+                                :element="inliner"
+                            />
+                        </td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+        <Caption v-if="caption" :caption="caption" />
+    </Block>
+</template>
+
+<style module>
+.table {
+    --tableBorder: color-mix(
+        in srgb,
+        var(--color-brand),
+        var(--color-border) 85%
+    );
+
+    --evenCellBg: color-mix(
+        in srgb,
+        light-dark(#f5f5f5, #282828),
+        var(--color-brand) 3%
+    );
+
+    --oddCellBg: color-mix(
+        in srgb,
+        light-dark(#f5f5f5, #282828),
+        var(--color-brand) 10%
+    );
+
+    [data-prose-accent] & {
+        --tableBorder: color-mix(
+            in srgb,
+            var(--accentBorder),
+            var(--color-border) 50%
+        );
+
+        --evenCellBg: color-mix(
+            in srgb,
+            light-dark(var(--color-bg-main), #202020),
+            var(--accentText) 12%
+        );
+
+        --oddCellBg: color-mix(
+            in srgb,
+            light-dark(var(--color-bg-main), #202020),
+            var(--accentText) 18%
+        );
+    }
+}
+</style>

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

@@ -0,0 +1,36 @@
+/**
+ * Tables are used to organize data into rows and columns.
+ * Rows (`<Tr>` — table row) goes first, then data cells (`<Td>` — table data) within each row which represent the columns.
+ *
+ * Tables can optionally have a `<Caption>` as their last child.
+ *
+ * @title Table
+ * @layout block
+ * @example
+ * ```tsx
+ * // Name  | Age | City
+ * // Alice | 30  | New York
+ * // Bob   | 25  | Los Angeles
+ * <Table>
+ *   <Tr>
+ *     <Td>Name</Td>
+ *     <Td>Age</Td>
+ *     <Td>City</Td>
+ *   </Tr>
+ *   <Tr>
+ *     <Td>Alice</Td>
+ *     <Td>30</Td>
+ *     <Td>New York</Td>
+ *   </Tr>
+ *   <Tr>
+ *     <Td>Bob</Td>
+ *     <Td>25</Td>
+ *     <Td>Los Angeles</Td>
+ *   </Tr>
+ *   <Caption>Example Table</Caption>
+ * </Table>
+ * ```
+ */
+export const Table = '_tag_';
+export const Tr = '_tag_';
+export const Td = '_tag_';

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

@@ -0,0 +1,30 @@
+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[];
+        }[];
+    })[];
+}>;
+export default _default;

package/dist/elements/table/app.js

@@ -0,0 +1,11 @@
+import { defineEruditProseAppElement } from "../../app/appElement.js";
+import { tableSchema } from "./core.js";
+export default defineEruditProseAppElement({
+	schema: tableSchema,
+	component: () => import("./Table.vue"),
+	languages: {
+		en: () => import("./languages/en.js"),
+		ru: () => import("./languages/ru.js")
+	},
+	icon: () => import("./icon.svg?raw")
+});

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

@@ -0,0 +1,324 @@
+import { type InlinerSchema, type TagChildren } from '@jsprose/core';
+export declare const tableDataSchema: {
+    name: "tableData";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: InlinerSchema[];
+};
+export declare const Td: import("@jsprose/core").Tag<"Td", {
+    name: "tableData";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: InlinerSchema[];
+}, TagChildren>;
+export declare const tableDataRegistryItem: import("@jsprose/core").RegistryItem<{
+    name: "tableData";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: InlinerSchema[];
+}, {
+    Td: import("@jsprose/core").Tag<"Td", {
+        name: "tableData";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: InlinerSchema[];
+    }, TagChildren>;
+}, undefined>;
+export declare const tableRowSchema: {
+    name: "tableRow";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: {
+        name: "tableData";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: InlinerSchema[];
+    }[];
+};
+export declare const Tr: import("@jsprose/core").Tag<"Tr", {
+    name: "tableRow";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: {
+        name: "tableData";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: InlinerSchema[];
+    }[];
+}, TagChildren>;
+export declare const tableRowRegistryItem: import("@jsprose/core").RegistryItem<{
+    name: "tableRow";
+    type: "inliner";
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: {
+        name: "tableData";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: InlinerSchema[];
+    }[];
+}, {
+    Tr: import("@jsprose/core").Tag<"Tr", {
+        name: "tableRow";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }[];
+    }, TagChildren>;
+}, undefined>;
+export declare const tableSchema: {
+    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: InlinerSchema[];
+    } | {
+        name: "tableRow";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }[];
+    })[];
+};
+export declare const Table: import("@jsprose/core").Tag<"Table", {
+    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: InlinerSchema[];
+    } | {
+        name: "tableRow";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }[];
+    })[];
+}, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+export declare const tableRegistryItem: import("@jsprose/core").RegistryItem<{
+    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: InlinerSchema[];
+    } | {
+        name: "tableRow";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }[];
+    })[];
+}, {
+    Table: import("@jsprose/core").Tag<"Table", {
+        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: InlinerSchema[];
+        } | {
+            name: "tableRow";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: {
+                name: "tableData";
+                type: "inliner";
+                linkable: false;
+                Data: undefined;
+                Storage: undefined;
+                Children: InlinerSchema[];
+            }[];
+        })[];
+    }, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+}, undefined>;
+declare const _default: [{
+    registryItem: import("@jsprose/core").RegistryItem<{
+        name: "tableData";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: InlinerSchema[];
+    }, {
+        Td: import("@jsprose/core").Tag<"Td", {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }, TagChildren>;
+    }, undefined>;
+}, {
+    registryItem: import("@jsprose/core").RegistryItem<{
+        name: "tableRow";
+        type: "inliner";
+        linkable: false;
+        Data: undefined;
+        Storage: undefined;
+        Children: {
+            name: "tableData";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: InlinerSchema[];
+        }[];
+    }, {
+        Tr: import("@jsprose/core").Tag<"Tr", {
+            name: "tableRow";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: {
+                name: "tableData";
+                type: "inliner";
+                linkable: false;
+                Data: undefined;
+                Storage: undefined;
+                Children: InlinerSchema[];
+            }[];
+        }, TagChildren>;
+    }, undefined>;
+}, {
+    registryItem: import("@jsprose/core").RegistryItem<{
+        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: InlinerSchema[];
+        } | {
+            name: "tableRow";
+            type: "inliner";
+            linkable: false;
+            Data: undefined;
+            Storage: undefined;
+            Children: {
+                name: "tableData";
+                type: "inliner";
+                linkable: false;
+                Data: undefined;
+                Storage: undefined;
+                Children: InlinerSchema[];
+            }[];
+        })[];
+    }, {
+        Table: import("@jsprose/core").Tag<"Table", {
+            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: InlinerSchema[];
+            } | {
+                name: "tableRow";
+                type: "inliner";
+                linkable: false;
+                Data: undefined;
+                Storage: undefined;
+                Children: {
+                    name: "tableData";
+                    type: "inliner";
+                    linkable: false;
+                    Data: undefined;
+                    Storage: undefined;
+                    Children: InlinerSchema[];
+                }[];
+            })[];
+        }, TagChildren & import("../../toc.js").ObjPropToc & import("../../snippet.js").ObjPropSnippet & import("../../snippet.js").ObjPropSearch & import("../../snippet.js").ObjPropQuick & import("../../snippet.js").ObjPropSeo>;
+    }, undefined>;
+}];
+export default _default;