erudit 4.1.1 → 4.2.0

package/server/erudit/db/schema/contentSnippets.ts

@@ -1,6 +1,6 @@
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
-import type { SnippetData } from '@erudit-js/prose';
+import type { Snippet } from '@erudit-js/prose';
 
 export const contentSnippets = sqliteTable('contentSnippets', {
   snippetId: integer().primaryKey({ autoIncrement: true }),
@@ -8,8 +8,8 @@ export const contentSnippets = sqliteTable('contentSnippets', {
   contentProseType: text().notNull().$type<ContentProseType>(),
   schemaName: text().notNull(),
   elementId: text().notNull(),
-  snippetData: text({ mode: 'json' }).$type<SnippetData>().notNull(),
+  snippetData: text({ mode: 'json' }).$type<Snippet>().notNull(),
   search: integer({ mode: 'boolean' }).notNull(),
-  quick: integer({ mode: 'boolean' }).notNull(),
+  key: integer({ mode: 'boolean' }).notNull(),
   seo: integer({ mode: 'boolean' }).notNull(),
 });

package/server/erudit/db/schema/contentUniques.ts

@@ -1,5 +1,5 @@
 import { primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 
 export const contentUniques = sqliteTable(
@@ -9,7 +9,7 @@ export const contentUniques = sqliteTable(
     contentProseType: text().notNull().$type<ContentProseType>(),
     uniqueName: text().notNull(),
     title: text(),
-    prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+    prose: text({ mode: 'json' }).$type<ProseElement>().notNull(),
   },
   (table) => [
     primaryKey({

package/server/erudit/db/schema/contributors.ts

@@ -1,5 +1,5 @@
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 export const contributors = sqliteTable('contributors', {
   contributorId: text().primaryKey(),
@@ -8,5 +8,5 @@ export const contributors = sqliteTable('contributors', {
   avatarExtension: text(),
   editor: integer({ mode: 'boolean' }),
   links: text({ mode: 'json' }).$type<Record<string, string>>(),
-  description: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+  description: text({ mode: 'json' }).$type<ProseElement>(),
 });

package/server/erudit/db/schema/news.ts

@@ -1,7 +1,7 @@
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 export const news = sqliteTable('news', {
   date: text().primaryKey(),
-  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+  prose: text({ mode: 'json' }).$type<ProseElement>().notNull(),
 });

package/server/erudit/db/schema/pages.ts

@@ -1,7 +1,7 @@
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 export const pages = sqliteTable('pages', {
   fullId: text().primaryKey(),
-  prose: text({ mode: 'json' }).$type<ProseElement<AnySchema>>().notNull(),
+  prose: text({ mode: 'json' }).$type<ProseElement>().notNull(),
 });

package/server/erudit/db/schema/topics.ts

@@ -1,9 +1,9 @@
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import type { ProseElement } from 'tsprose';
 
 export const topics = sqliteTable('topics', {
   fullId: text().primaryKey(),
-  article: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-  summary: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
-  practice: text({ mode: 'json' }).$type<ProseElement<AnySchema>>(),
+  article: text({ mode: 'json' }).$type<ProseElement>(),
+  summary: text({ mode: 'json' }).$type<ProseElement>(),
+  practice: text({ mode: 'json' }).$type<ProseElement>(),
 });

package/server/erudit/global.ts

@@ -10,6 +10,8 @@ import type { EruditServerLogger } from './logger';
 import type { EruditServerPaths } from './path';
 import type { EruditServerRepository } from './repository';
 
+import { registerProseGlobals } from '#erudit/prose/global';
+
 export const ERUDIT: {
   buildError: EruditServerBuildError;
   buildPromise: Promise<void>;
@@ -36,3 +38,5 @@ Object.assign(globalThis, {
   defineProse,
   Include,
 });
+
+registerProseGlobals();

package/server/erudit/importer.ts

@@ -1,6 +1,6 @@
 import { createJiti, type Jiti, type JitiOptions } from 'jiti';
-import { insertDocumentId } from '@jsprose/core';
 import { sn } from 'unslash';
+import { injectDocumentId } from 'tsprose';
 import {
   pathToDocumentId,
   stringifyDocumentId,
@@ -45,18 +45,18 @@ export async function setupServerImporter() {
       const documentId = pathToDocumentId(filename, ERUDIT.paths.project());
 
       if (documentId) {
-        code = insertDocumentId({
+        code = injectDocumentId(
+          stringifyDocumentId(documentId),
           code,
-          documentId: stringifyDocumentId(documentId),
-          aliasName: 'defineProse',
-        });
+          'defineProse',
+        );
       }
 
       //
       // Problem Scripts
       //
 
-      code = insertProblemScriptId(filename, code);
+      code = insertProblemScriptId(toRelPath(filename), code);
 
       return { code };
     },
@@ -77,18 +77,26 @@ function createBaseJitiOptions(): JitiOptions {
     },
     jsx: {
       runtime: 'automatic',
-      importSource: '@jsprose/core',
+      importSource: 'tsprose',
     },
   };
 }
 
+function toRelPath(filename: string): string {
+  const projectPath = ERUDIT.paths.project();
+  if (filename.startsWith(projectPath + '/')) {
+    return filename.slice(projectPath.length + 1);
+  }
+  return filename;
+}
+
 function tryStaticAssetModule(filename: unknown) {
   if (
     typeof filename === 'string' &&
     STATIC_ASSET_EXTENSIONS.some((ext) => filename.endsWith('.' + ext))
   ) {
     return {
-      code: `exports.default = "${filename}";`,
+      code: `exports.default = "${toRelPath(filename)}";`,
     };
   }
 }

package/server/erudit/index.ts

@@ -61,9 +61,6 @@ ${escapeHtml(ERUDIT.buildError.stack || '')}
 
 async function setupServer() {
   try {
-    const { registerProseGlobals } = await import('#erudit/prose/global');
-    registerProseGlobals();
-
     const runtimeConfig = useRuntimeConfig();
 
     ERUDIT.mode = runtimeConfig.public.eruditMode as EruditMode;

package/server/erudit/language/list/en.ts

@@ -80,6 +80,7 @@ export const phrases: LanguagePhrases = {
   no_contribution: 'No contributions yet.',
   editor: 'Editor',
   materials: 'Materials',
+  updated: 'Updated',
   x_sponsors: (count: number) => m(count, 'Sponsor', 'Sponsors'),
   x_contributors: (count: number) => m(count, 'Contributor', 'Contributors'),
   news: 'News',

package/server/erudit/language/list/ru.ts

@@ -81,6 +81,7 @@ export const phrases: LanguagePhrases = {
   no_contribution: 'Пока что вклада нет.',
   editor: 'Редактор',
   materials: 'Материалы',
+  updated: 'Обновлено',
   x_sponsors: (count: number) => m(count, 'Спонсор', 'Спонсора', 'Спонсоров'),
   x_contributors: (count: number) => m(count, 'Автор', 'Автора', 'Авторов'),
   news: 'Новости',

package/server/erudit/news/build.ts

@@ -1,9 +1,7 @@
 import { existsSync } from 'node:fs';
 import { inArray } from 'drizzle-orm';
 import { globSync } from 'glob';
-import type { AnySchema, RawElement } from '@jsprose/core';
-
-import { resolveEruditProse } from '../prose/repository/resolve';
+import type { RawElement } from 'tsprose';
 
 let initialBuild = true;
 
@@ -88,7 +86,7 @@ async function buildNewsItem(filename: string) {
     `Building news item ${ERUDIT.log.stress(filename)}...`,
   );
 
-  let newsModule: { default: RawElement<AnySchema> } | undefined;
+  let newsModule: { default: RawElement } | undefined;
 
   try {
     newsModule = await ERUDIT.import(`${newsRoot()}/${filename}`);
@@ -103,10 +101,12 @@ async function buildNewsItem(filename: string) {
     return;
   }
 
-  const resolvedProse = await resolveEruditProse(newsModule.default, false);
+  const resolvedProse = await ERUDIT.repository.prose.fromRaw({
+    rawProse: newsModule.default,
+  });
 
   await ERUDIT.db.insert(ERUDIT.db.schema.news).values({
     date: filename.replace('.tsx', ''),
-    prose: resolvedProse.proseElement,
+    prose: resolvedProse.prose,
   });
 }

package/server/erudit/news/repository/batch.ts

@@ -6,7 +6,7 @@ export async function countNewsBatches(): Promise<number> {
   const newsTotal = await ERUDIT.db
     .select({ count: count() })
     .from(ERUDIT.db.schema.news)
-    .then((result) => result[0].count);
+    .then((result) => result[0]!.count);
 
   return Math.ceil(newsTotal / newsNumberPerBatch);
 }
@@ -15,7 +15,7 @@ export async function getNewsNextBatch(index: number): Promise<NewsBatch> {
   const newsTotal = await ERUDIT.db
     .select({ count: count() })
     .from(ERUDIT.db.schema.news)
-    .then((result) => result[0].count);
+    .then((result) => result[0]!.count);
 
   const dbNews = await ERUDIT.db.query.news.findMany({
     columns: {

package/server/erudit/prose/repository/finalize.ts

@@ -1,12 +1,9 @@
 import {
-  fillStorage,
+  fillProseStorage,
   isProseElement,
-  PROSE_REGISTRY,
-  type AnySchema,
-  type FinalizedProse,
-  type GenericStorage,
   type ProseElement,
-} from '@jsprose/core';
+  type ProseWithStorage,
+} from 'tsprose';
 import { imageSchema } from '@erudit-js/prose/elements/image/core';
 import { videoSchema } from '@erudit-js/prose/elements/video/core';
 import { calloutSchema } from '@erudit-js/prose/elements/callout/core';
@@ -27,42 +24,42 @@ import { createCalloutStorage } from '../storage/callout';
 import { createLinkStorage } from '../storage/link';
 import { createProblemScriptStorage } from '../storage/problemScript';
 
+import { coreElements } from '#erudit/prose/global';
+
 export async function finalizeProse(
-  proseElement: ProseElement<AnySchema>,
-): Promise<FinalizedProse> {
-  const storage: GenericStorage = {};
+  prose: ProseElement,
+): Promise<ProseWithStorage> {
+  const storageCreators = Object.fromEntries(
+    Object.entries(coreElements)
+      .map(([key, coreElement]) => [key, coreElement.createStorage])
+      .filter(([, createStorage]) => Boolean(createStorage)),
+  );
 
-  await fillStorage({
-    storage,
-    proseElement,
-    storageCreators: PROSE_REGISTRY.getStorageCreators(),
-    step: async (element) => {
+  const storage = await fillProseStorage({
+    prose,
+    storageCreators,
+    alterValue: async ({ element, storageKey }) => {
       switch (true) {
         case isProseElement(element, imageSchema):
-          await createImageStorage(element, storage);
-          break;
+          return await createImageStorage(element);
         case isProseElement(element, videoSchema):
-          await createVideoStorage(element, storage);
-          break;
+          return createVideoStorage(element);
         case isProseElement(element, calloutSchema):
-          await createCalloutStorage(element, storage);
-          break;
+          return createCalloutStorage(element);
         case isProseElement(element, refSchema):
         case isProseElement(element, referenceSchema):
         case isProseElement(element, depSchema):
         case isProseElement(element, dependencySchema):
-          await createLinkStorage(element, storage);
-          break;
+          return await createLinkStorage(element, storageKey);
         case isProseElement(element, problemSchema):
         case isProseElement(element, subProblemSchema):
-          await createProblemScriptStorage(element, storage);
-          break;
+          return createProblemScriptStorage(element, storageKey);
       }
     },
   });
 
   return {
-    proseElement,
+    prose,
     storage,
   };
 }

package/server/erudit/prose/repository/get.ts

@@ -1,12 +1,12 @@
 import { eq } from 'drizzle-orm';
-import type { AnySchema, ProseElement } from '@jsprose/core';
+import { type ProseElement } from 'tsprose';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 import { isTopicPart } from '@erudit-js/core/content/topic';
 
 export async function getContentProse(
   contentType: ContentProseType,
   contentId: string,
-): Promise<ProseElement<AnySchema>> {
+): Promise<ProseElement> {
   const navNode = ERUDIT.contentNav.getNodeOrThrow(contentId);
   const fullContentId = navNode.fullId;
 
@@ -40,7 +40,7 @@ export async function getContentProse(
 
 export async function getContributorProse(
   contributorId: string,
-): Promise<ProseElement<AnySchema> | undefined> {
+): Promise<ProseElement | undefined> {
   const dbContributor = await ERUDIT.db.query.contributors.findFirst({
     columns: {
       description: true,
@@ -50,5 +50,3 @@ export async function getContributorProse(
 
   return dbContributor?.description || undefined;
 }
-
-// @TODO: Get news item prose

package/server/erudit/prose/repository/rawToProse.ts

@@ -0,0 +1,31 @@
+import {
+  eruditRawToProse,
+  type EruditRawToProseTask,
+  type RawToProseSchemaHooks,
+} from '@erudit-js/prose';
+import { coreElements } from '#erudit/prose/global';
+
+function buildSchemaHooks(): RawToProseSchemaHooks {
+  const hooks: RawToProseSchemaHooks = new Map();
+  for (const coreElement of Object.values(coreElements)) {
+    if (coreElement.rawToProseHook) {
+      hooks.set(coreElement.schema, coreElement.rawToProseHook);
+    }
+  }
+  return hooks;
+}
+
+export async function serverRawToProse(task: EruditRawToProseTask) {
+  const elementSchemaHooks = buildSchemaHooks();
+
+  // Merge caller-provided schemaHooks on top of the element hooks
+  const mergedSchemaHooks: RawToProseSchemaHooks = task.schemaHooks
+    ? new Map([...elementSchemaHooks, ...task.schemaHooks])
+    : elementSchemaHooks;
+
+  return eruditRawToProse({
+    ...task,
+    language: ERUDIT.config.public.language.current,
+    schemaHooks: mergedSchemaHooks,
+  });
+}

package/server/erudit/prose/storage/callout.ts

@@ -1,14 +1,16 @@
-import type { ProseElement, GenericStorage } from '@jsprose/core';
-import type { calloutSchema } from '@erudit-js/prose/elements/callout/core';
+import type { ToProseElement } from 'tsprose';
+import type {
+  CalloutSchema,
+  CalloutStorage,
+} from '@erudit-js/prose/elements/callout/core';
 import { createCalloutStorage as _createCalloutStorage } from '@erudit-js/prose/elements/callout/storage';
 
-export async function createCalloutStorage(
-  element: ProseElement<typeof calloutSchema>,
-  storage: GenericStorage,
-) {
+export function createCalloutStorage(
+  element: ToProseElement<CalloutSchema>,
+): CalloutStorage {
   const runtimeConfig = useRuntimeConfig();
 
-  storage[element.storageKey!] = _createCalloutStorage(
+  return _createCalloutStorage(
     ERUDIT.paths.project(),
     runtimeConfig.app.baseURL,
     element.data.iconSrc,

package/server/erudit/prose/storage/image.ts

@@ -1,22 +1,19 @@
-import type { GenericStorage, ProseElement } from '@jsprose/core';
+import type { ToProseElement } from 'tsprose';
 import type {
-  imageSchema,
+  ImageSchema,
   ImageStorage,
 } from '@erudit-js/prose/elements/image/core';
 import { createImageStorage as _createImageStorage } from '@erudit-js/prose/elements/image/storage';
 
 export async function createImageStorage(
-  element: ProseElement<typeof imageSchema>,
-  storage: GenericStorage,
-) {
+  element: ToProseElement<ImageSchema>,
+): Promise<ImageStorage> {
   const runtimeConfig = useRuntimeConfig();
 
-  const imageAbsPath = element.data.src;
-  const imageStorage = await _createImageStorage(
+  const imageRelSrc = element.data.src;
+  return (await _createImageStorage(
     ERUDIT.paths.project(),
     runtimeConfig.app.baseURL,
-    imageAbsPath,
-  );
-
-  storage[element.storageKey!] = imageStorage satisfies ImageStorage;
+    imageRelSrc,
+  )) satisfies ImageStorage;
 }

package/server/erudit/prose/storage/link.ts

@@ -1,34 +1,28 @@
-import {
-  ProseError,
-  uniqueName2Id,
-  type GenericStorage,
-  type ProseElement,
-} from '@jsprose/core';
-
+import type { ToProseElement } from 'tsprose';
 import { isTopicPart } from '@erudit-js/core/content/topic';
 import type { ContentPointer } from '@erudit-js/core/content/pointer';
 import type {
-  referenceSchema,
-  refSchema,
+  ReferenceSchema,
+  RefSchema,
 } from '@erudit-js/prose/elements/link/reference/core';
 import type {
-  dependencySchema,
-  depSchema,
+  DependencySchema,
+  DepSchema,
 } from '@erudit-js/prose/elements/link/dependency/core';
 import type { LinkStorage } from '@erudit-js/prose/elements/link/storage';
 
 export async function createLinkStorage(
   element:
-    | ProseElement<typeof refSchema>
-    | ProseElement<typeof referenceSchema>
-    | ProseElement<typeof depSchema>
-    | ProseElement<typeof dependencySchema>,
-  storage: GenericStorage,
-) {
+    | ToProseElement<RefSchema>
+    | ToProseElement<ReferenceSchema>
+    | ToProseElement<DepSchema>
+    | ToProseElement<DependencySchema>,
+  storageKey: string,
+): Promise<LinkStorage> {
   try {
     let linkStorage: LinkStorage | undefined;
 
-    const storageKeyParts = element.storageKey!.split('/');
+    const storageKeyParts = storageKey.split('/');
     const linkType = storageKeyParts[0];
     const strProseLink = storageKeyParts.slice(1).join('/');
 
@@ -72,7 +66,7 @@ export async function createLinkStorage(
         if (contentPointer.type === 'topic') {
           linkStorage = {
             type: 'unique',
-            schemaName: unique.prose.schemaName,
+            schemaName: unique.prose.schema.name,
             elementTitle: unique.title || undefined,
             content: {
               contentType: 'topic',
@@ -82,7 +76,7 @@ export async function createLinkStorage(
             resolvedHref: PAGES.topic(
               contentPointer.part,
               shortId,
-              uniqueName2Id(uniqueName),
+              unique.prose.id,
             ),
             previewRequest: {
               type: 'unique',
@@ -95,13 +89,13 @@ export async function createLinkStorage(
         } else {
           linkStorage = {
             type: 'unique',
-            schemaName: unique.prose.schemaName,
+            schemaName: unique.prose.schema.name,
             elementTitle: unique.title || undefined,
             content: {
               contentType: contentPointer.type,
               contentTitle,
             },
-            resolvedHref: PAGES.page(shortId, uniqueName2Id(uniqueName)),
+            resolvedHref: PAGES.page(shortId, unique.prose.id),
             previewRequest: {
               type: 'unique',
               contentFullId: contentPointer.id,
@@ -160,14 +154,14 @@ export async function createLinkStorage(
     }
 
     if (!linkStorage) {
-      throw new ProseError(
-        `Unable to create prose link storage for link: ${element.storageKey}`,
+      throw new Error(
+        `Unable to create prose link storage for link: ${storageKey}`,
       );
     }
 
-    storage[element.storageKey!] = linkStorage;
+    return linkStorage;
   } catch (error) {
-    storage[element.storageKey!] = {
+    return {
       type: 'error',
       error: error instanceof Error ? error.message : String(error),
     };
@@ -178,7 +172,7 @@ async function getContentPointerFor(
   contentId: string,
 ): Promise<ContentPointer> {
   if (!contentId) {
-    throw new ProseError(`Invalid content ID: "${contentId}"!`);
+    throw new Error(`Invalid content ID: "${contentId}"!`);
   }
 
   const contentNavNode = ERUDIT.contentNav.getNode(contentId);
@@ -188,7 +182,7 @@ async function getContentPointerFor(
       contentNavNode.fullId,
     );
     if (hidden) {
-      throw new ProseError(`Target content is hidden!`);
+      throw new Error(`Target content is hidden!`);
     }
 
     if (contentNavNode.type === 'topic') {
@@ -213,7 +207,7 @@ async function getContentPointerFor(
   const maybeTopicPart = contentIdParts.pop()!;
 
   if (!isTopicPart(maybeTopicPart)) {
-    throw new ProseError(
+    throw new Error(
       `Prose link part "${contentId}" must be a valid topic part!`,
     );
   }
@@ -230,7 +224,5 @@ async function getContentPointerFor(
     };
   }
 
-  throw new ProseError(
-    `Unable to find content for prose link: "${contentId}"!`,
-  );
+  throw new Error(`Unable to find content for prose link: "${contentId}"!`);
 }

package/server/erudit/prose/storage/problemScript.ts

@@ -1,23 +1,17 @@
-import type { GenericStorage, ProseElement } from '@jsprose/core';
-import type { problemSchema } from '@erudit-js/prose/elements/problem/problem';
-import type { subProblemSchema } from '@erudit-js/prose/elements/problem/problems';
+import type { ToProseElement } from 'tsprose';
+import type { ProblemSchema } from '@erudit-js/prose/elements/problem/problem';
+import type { SubProblemSchema } from '@erudit-js/prose/elements/problem/problems';
 import { createProblemScriptStorage as _createProblemScriptStorage } from '@erudit-js/prose/elements/problem/storage';
 
-export async function createProblemScriptStorage(
-  element:
-    | ProseElement<typeof problemSchema>
-    | ProseElement<typeof subProblemSchema>,
-  storage: GenericStorage,
+export function createProblemScriptStorage(
+  element: ToProseElement<ProblemSchema> | ToProseElement<SubProblemSchema>,
+  storageKey: string,
 ) {
-  if (!element.storageKey) {
-    return;
-  }
-
   const runtimeConfig = useRuntimeConfig();
 
-  storage[element.storageKey!] = _createProblemScriptStorage(
+  return _createProblemScriptStorage(
     ERUDIT.paths.project(),
     runtimeConfig.app.baseURL,
-    element.storageKey.replace('problemScript:', ''),
+    storageKey.replace('problemScript:', ''),
   );
 }

package/server/erudit/prose/storage/video.ts

@@ -1,14 +1,16 @@
-import type { GenericStorage, ProseElement } from '@jsprose/core';
-import type { videoSchema } from '@erudit-js/prose/elements/video/core';
+import type { ToProseElement } from 'tsprose';
+import type {
+  VideoSchema,
+  VideoStorage,
+} from '@erudit-js/prose/elements/video/core';
 import { createVideoStorage as _createVideoStorage } from '@erudit-js/prose/elements/video/storage';
 
-export async function createVideoStorage(
-  element: ProseElement<typeof videoSchema>,
-  storage: GenericStorage,
-) {
+export function createVideoStorage(
+  element: ToProseElement<VideoSchema>,
+): VideoStorage {
   const runtimeConfig = useRuntimeConfig();
 
-  storage[element.storageKey!] = _createVideoStorage(
+  return _createVideoStorage(
     ERUDIT.paths.project(),
     runtimeConfig.app.baseURL,
     element.data.src,