erudit 4.0.0-dev.4 → 4.0.0

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

@@ -1,226 +1,222 @@
-import {
-    ProseError,
-    uniqueName2Id,
-    type GenericStorage,
-    type ProseElement,
-} from '@jsprose/core';
-
-import { isTopicPart } from '@erudit-js/core/content/topic';
-import type { ContentPointer } from '@erudit-js/core/content/pointer';
-import type {
-    referenceSchema,
-    refSchema,
-} from '@erudit-js/prose/elements/link/reference/core';
-import type {
-    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,
-) {
-    let linkStorage: LinkStorage | undefined;
-
-    const storageKeyParts = element.storageKey!.split('/');
-    const linkType = storageKeyParts[0];
-    const strProseLink = storageKeyParts.slice(1).join('/');
-
-    if (linkType === '<link:direct>') {
-        linkStorage = {
-            type: 'direct',
-            resolvedHref: strProseLink,
-            previewRequest: {
-                type: 'direct-link',
-                href: strProseLink,
-            },
-        };
-    } else if (linkType === '<link:global>') {
-        const proseLinkParts = strProseLink.split('/');
-        const uniquePart = proseLinkParts.pop();
-
-        if (uniquePart?.startsWith('$')) {
-            //
-            // Unique link
-            //
-
-            const contentPointer = await getContentPointerFor(
-                proseLinkParts.join('/'),
-            );
-
-            const shortId = ERUDIT.contentNav.getNodeOrThrow(
-                contentPointer.id,
-            ).shortId;
-
-            const contentTitle = await ERUDIT.repository.content.title(
-                contentPointer.id,
-            );
-
-            const uniqueName = uniquePart.slice(1);
-            const unique = await ERUDIT.repository.content.unique(
-                contentPointer.id,
-                contentPointer.type === 'topic' ? contentPointer.part : 'page',
-                uniqueName,
-            );
-
-            if (contentPointer.type === 'topic') {
-                linkStorage = {
-                    type: 'unique',
-                    schemaName: unique.prose.schemaName,
-                    elementTitle: unique.title || undefined,
-                    content: {
-                        contentType: 'topic',
-                        contentTitle,
-                        topicPart: contentPointer.part,
-                    },
-                    resolvedHref: PAGES.topic(
-                        contentPointer.part,
-                        shortId,
-                        uniqueName2Id(uniqueName),
-                    ),
-                    previewRequest: {
-                        type: 'unique',
-                        contentFullId: contentPointer.id,
-                        contentType: 'topic',
-                        topicPart: contentPointer.part,
-                        uniqueName: uniqueName,
-                    },
-                };
-            } else {
-                linkStorage = {
-                    type: 'unique',
-                    schemaName: unique.prose.schemaName,
-                    elementTitle: unique.title || undefined,
-                    content: {
-                        contentType: contentPointer.type,
-                        contentTitle,
-                    },
-                    resolvedHref: PAGES.page(
-                        shortId,
-                        uniqueName2Id(uniqueName),
-                    ),
-                    previewRequest: {
-                        type: 'unique',
-                        contentFullId: contentPointer.id,
-                        contentType: 'page',
-                        uniqueName: uniqueName,
-                    },
-                };
-            }
-        } else {
-            //
-            // Content item link
-            //
-
-            const contentPointer = await getContentPointerFor(strProseLink);
-
-            const shortId = ERUDIT.contentNav.getNodeOrThrow(
-                contentPointer.id,
-            ).shortId;
-
-            const contentTitle = await ERUDIT.repository.content.title(
-                contentPointer.id,
-            );
-
-            if (contentPointer.type === 'topic') {
-                linkStorage = {
-                    type: 'contentItem',
-                    content: {
-                        contentType: 'topic',
-                        contentTitle,
-                        topicPart: contentPointer.part,
-                    },
-                    resolvedHref: PAGES.topic(contentPointer.part, shortId),
-                    previewRequest: {
-                        type: 'content-page',
-                        contentType: 'topic',
-                        topicPart: contentPointer.part,
-                        fullId: contentPointer.id,
-                    },
-                };
-            } else {
-                linkStorage = {
-                    type: 'contentItem',
-                    content: {
-                        contentType: contentPointer.type,
-                        contentTitle,
-                    },
-                    resolvedHref: PAGES[contentPointer.type](shortId),
-                    previewRequest: {
-                        type: 'content-page',
-                        contentType: contentPointer.type,
-                        fullId: contentPointer.id,
-                    },
-                };
-            }
-        }
-    }
-
-    if (!linkStorage) {
-        throw new ProseError(
-            `Unable to create prose link storage for link: ${element.storageKey}`,
-        );
-    }
-
-    storage[element.storageKey!] = linkStorage;
-}
-
-async function getContentPointerFor(
-    contentId: string,
-): Promise<ContentPointer> {
-    if (!contentId) {
-        throw new ProseError(`Invalid content ID: "${contentId}"!`);
-    }
-
-    const contentNavNode = ERUDIT.contentNav.getNode(contentId);
-
-    if (contentNavNode) {
-        if (contentNavNode.type === 'topic') {
-            const defaultTopicPart =
-                await ERUDIT.repository.content.defaultTopicPart(
-                    contentNavNode.fullId,
-                );
-
-            return {
-                type: 'topic',
-                id: contentNavNode.fullId,
-                part: defaultTopicPart,
-            };
-        } else {
-            return {
-                type: contentNavNode.type,
-                id: contentNavNode.fullId,
-            };
-        }
-    }
-
-    const contentIdParts = contentId.split('/');
-    const maybeTopicPart = contentIdParts.pop()!;
-
-    if (!isTopicPart(maybeTopicPart)) {
-        throw new ProseError(
-            `Prose link part "${contentId}" must be a valid topic part!`,
-        );
-    }
-
-    const shortenedContentNavNode = ERUDIT.contentNav.getNode(
-        contentIdParts.join('/'),
-    );
-
-    if (shortenedContentNavNode) {
-        return {
-            type: 'topic',
-            id: shortenedContentNavNode.fullId,
-            part: maybeTopicPart,
-        };
-    }
-
-    throw new ProseError(
-        `Unable to find content for prose link: "${contentId}"!`,
-    );
-}
+import {
+  ProseError,
+  uniqueName2Id,
+  type GenericStorage,
+  type ProseElement,
+} from '@jsprose/core';
+
+import { isTopicPart } from '@erudit-js/core/content/topic';
+import type { ContentPointer } from '@erudit-js/core/content/pointer';
+import type {
+  referenceSchema,
+  refSchema,
+} from '@erudit-js/prose/elements/link/reference/core';
+import type {
+  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,
+) {
+  let linkStorage: LinkStorage | undefined;
+
+  const storageKeyParts = element.storageKey!.split('/');
+  const linkType = storageKeyParts[0];
+  const strProseLink = storageKeyParts.slice(1).join('/');
+
+  if (linkType === '<link:direct>') {
+    linkStorage = {
+      type: 'direct',
+      resolvedHref: strProseLink,
+      previewRequest: {
+        type: 'direct-link',
+        href: strProseLink,
+      },
+    };
+  } else if (linkType === '<link:global>') {
+    const proseLinkParts = strProseLink.split('/');
+    const uniquePart = proseLinkParts.pop();
+
+    if (uniquePart?.startsWith('$')) {
+      //
+      // Unique link
+      //
+
+      const contentPointer = await getContentPointerFor(
+        proseLinkParts.join('/'),
+      );
+
+      const shortId = ERUDIT.contentNav.getNodeOrThrow(
+        contentPointer.id,
+      ).shortId;
+
+      const contentTitle = await ERUDIT.repository.content.title(
+        contentPointer.id,
+      );
+
+      const uniqueName = uniquePart.slice(1);
+      const unique = await ERUDIT.repository.content.unique(
+        contentPointer.id,
+        contentPointer.type === 'topic' ? contentPointer.part : 'page',
+        uniqueName,
+      );
+
+      if (contentPointer.type === 'topic') {
+        linkStorage = {
+          type: 'unique',
+          schemaName: unique.prose.schemaName,
+          elementTitle: unique.title || undefined,
+          content: {
+            contentType: 'topic',
+            contentTitle,
+            topicPart: contentPointer.part,
+          },
+          resolvedHref: PAGES.topic(
+            contentPointer.part,
+            shortId,
+            uniqueName2Id(uniqueName),
+          ),
+          previewRequest: {
+            type: 'unique',
+            contentFullId: contentPointer.id,
+            contentType: 'topic',
+            topicPart: contentPointer.part,
+            uniqueName: uniqueName,
+          },
+        };
+      } else {
+        linkStorage = {
+          type: 'unique',
+          schemaName: unique.prose.schemaName,
+          elementTitle: unique.title || undefined,
+          content: {
+            contentType: contentPointer.type,
+            contentTitle,
+          },
+          resolvedHref: PAGES.page(shortId, uniqueName2Id(uniqueName)),
+          previewRequest: {
+            type: 'unique',
+            contentFullId: contentPointer.id,
+            contentType: 'page',
+            uniqueName: uniqueName,
+          },
+        };
+      }
+    } else {
+      //
+      // Content item link
+      //
+
+      const contentPointer = await getContentPointerFor(strProseLink);
+
+      const shortId = ERUDIT.contentNav.getNodeOrThrow(
+        contentPointer.id,
+      ).shortId;
+
+      const contentTitle = await ERUDIT.repository.content.title(
+        contentPointer.id,
+      );
+
+      if (contentPointer.type === 'topic') {
+        linkStorage = {
+          type: 'contentItem',
+          content: {
+            contentType: 'topic',
+            contentTitle,
+            topicPart: contentPointer.part,
+          },
+          resolvedHref: PAGES.topic(contentPointer.part, shortId),
+          previewRequest: {
+            type: 'content-page',
+            contentType: 'topic',
+            topicPart: contentPointer.part,
+            fullId: contentPointer.id,
+          },
+        };
+      } else {
+        linkStorage = {
+          type: 'contentItem',
+          content: {
+            contentType: contentPointer.type,
+            contentTitle,
+          },
+          resolvedHref: PAGES[contentPointer.type](shortId),
+          previewRequest: {
+            type: 'content-page',
+            contentType: contentPointer.type,
+            fullId: contentPointer.id,
+          },
+        };
+      }
+    }
+  }
+
+  if (!linkStorage) {
+    throw new ProseError(
+      `Unable to create prose link storage for link: ${element.storageKey}`,
+    );
+  }
+
+  storage[element.storageKey!] = linkStorage;
+}
+
+async function getContentPointerFor(
+  contentId: string,
+): Promise<ContentPointer> {
+  if (!contentId) {
+    throw new ProseError(`Invalid content ID: "${contentId}"!`);
+  }
+
+  const contentNavNode = ERUDIT.contentNav.getNode(contentId);
+
+  if (contentNavNode) {
+    if (contentNavNode.type === 'topic') {
+      const defaultTopicPart = await ERUDIT.repository.content.defaultTopicPart(
+        contentNavNode.fullId,
+      );
+
+      return {
+        type: 'topic',
+        id: contentNavNode.fullId,
+        part: defaultTopicPart,
+      };
+    } else {
+      return {
+        type: contentNavNode.type,
+        id: contentNavNode.fullId,
+      };
+    }
+  }
+
+  const contentIdParts = contentId.split('/');
+  const maybeTopicPart = contentIdParts.pop()!;
+
+  if (!isTopicPart(maybeTopicPart)) {
+    throw new ProseError(
+      `Prose link part "${contentId}" must be a valid topic part!`,
+    );
+  }
+
+  const shortenedContentNavNode = ERUDIT.contentNav.getNode(
+    contentIdParts.join('/'),
+  );
+
+  if (shortenedContentNavNode) {
+    return {
+      type: 'topic',
+      id: shortenedContentNavNode.fullId,
+      part: maybeTopicPart,
+    };
+  }
+
+  throw new ProseError(
+    `Unable to find content for prose link: "${contentId}"!`,
+  );
+}

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

@@ -1,21 +1,23 @@
-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 { createProblemScriptStorage as _createProblemScriptStorage } from '@erudit-js/prose/elements/problem/storage';
-
-export async function createProblemScriptStorage(
-    element:
-        | ProseElement<typeof problemSchema>
-        | ProseElement<typeof subProblemSchema>,
-    storage: GenericStorage,
-) {
-    if (!element.storageKey) {
-        return;
-    }
-
-    storage[element.storageKey!] = _createProblemScriptStorage(
-        ERUDIT.config.paths.project,
-        ERUDIT.config.public.project.baseUrl,
-        element.storageKey.replace('problemScript:', ''),
-    );
-}
+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 { createProblemScriptStorage as _createProblemScriptStorage } from '@erudit-js/prose/elements/problem/storage';
+
+export async function createProblemScriptStorage(
+  element:
+    | ProseElement<typeof problemSchema>
+    | ProseElement<typeof subProblemSchema>,
+  storage: GenericStorage,
+) {
+  if (!element.storageKey) {
+    return;
+  }
+
+  const runtimeConfig = useRuntimeConfig();
+
+  storage[element.storageKey!] = _createProblemScriptStorage(
+    ERUDIT.paths.project(),
+    runtimeConfig.app.baseURL,
+    element.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 { createVideoStorage as _createVideoStorage } from '@erudit-js/prose/elements/video/storage';
-
-export async function createVideoStorage(
-    element: ProseElement<typeof videoSchema>,
-    storage: GenericStorage,
-) {
-    storage[element.storageKey!] = _createVideoStorage(
-        ERUDIT.config.paths.project,
-        ERUDIT.config.public.project.baseUrl,
-        element.data.src,
-    );
-}
+import type { GenericStorage, ProseElement } from '@jsprose/core';
+import type { videoSchema } 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,
+) {
+  const runtimeConfig = useRuntimeConfig();
+
+  storage[element.storageKey!] = _createVideoStorage(
+    ERUDIT.paths.project(),
+    runtimeConfig.app.baseURL,
+    element.data.src,
+  );
+}

package/server/erudit/prose/transform/bundleProblemScript.ts

@@ -1,6 +1,6 @@
-export async function bundleProblemScript(problemId: string) {
-    // Создаем фейковый stdin для esbuild, в котором импортирует требуемый скрипт из файла, где он объявлен
-    // Так на выходе получим только бандл скрипта, без лишних зависимостей
-}
-
-// Функция для вызова ESBuild бандлера, чтобы собирать problem скрипты и прочее
+export async function bundleProblemScript(problemId: string) {
+  // Создаем фейковый stdin для esbuild, в котором импортирует требуемый скрипт из файла, где он объявлен
+  // Так на выходе получим только бандл скрипта, без лишних зависимостей
+}
+
+// Функция для вызова ESBuild бандлера, чтобы собирать problem скрипты и прочее

package/server/erudit/prose/transform/extensions.ts

@@ -1,15 +1,15 @@
-export const CODE_EXTENSIONS = ['json', 'ts', 'tsx', 'js', 'jsx'];
-
-export const STATIC_ASSET_EXTENSIONS = [
-    'png',
-    'jpg',
-    'jpeg',
-    'gif',
-    'bmp',
-    'webp',
-    'svg',
-    'mp4',
-    'webm',
-];
-
-export const EXTENSIONS = [...CODE_EXTENSIONS, ...STATIC_ASSET_EXTENSIONS];
+export const CODE_EXTENSIONS = ['json', 'ts', 'tsx', 'js', 'jsx'];
+
+export const STATIC_ASSET_EXTENSIONS = [
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'bmp',
+  'webp',
+  'svg',
+  'mp4',
+  'webm',
+];
+
+export const EXTENSIONS = [...CODE_EXTENSIONS, ...STATIC_ASSET_EXTENSIONS];

package/server/erudit/quote/repository/ids.ts

@@ -1,31 +1,31 @@
-import { createQuoteId, type QuoteIds } from '@erudit-js/core/quote';
-import { eq } from 'drizzle-orm';
-
-export async function getQuoteIds(): Promise<QuoteIds> {
-    const ids: QuoteIds = {};
-
-    const dbCameos = await ERUDIT.db.query.cameos.findMany({
-        columns: { cameoId: true },
-    });
-
-    if (dbCameos.length > 0) {
-        ids.cameo = dbCameos.map((dbCameo) =>
-            createQuoteId('cameo', dbCameo.cameoId),
-        );
-    }
-
-    if (ERUDIT.config.public.project.sponsors?.enabled) {
-        const dbSponsors = await ERUDIT.db.query.sponsors.findMany({
-            columns: { sponsorId: true },
-            where: eq(ERUDIT.db.schema.sponsors.hasMessages, true),
-        });
-
-        if (dbSponsors.length > 0) {
-            ids.sponsor = dbSponsors.map((dbSponsor) =>
-                createQuoteId('sponsor', dbSponsor.sponsorId),
-            );
-        }
-    }
-
-    return ids;
-}
+import { createQuoteId, type QuoteIds } from '@erudit-js/core/quote';
+import { eq } from 'drizzle-orm';
+
+export async function getQuoteIds(): Promise<QuoteIds> {
+  const ids: QuoteIds = {};
+
+  const dbCameos = await ERUDIT.db.query.cameos.findMany({
+    columns: { cameoId: true },
+  });
+
+  if (dbCameos.length > 0) {
+    ids.cameo = dbCameos.map((dbCameo) =>
+      createQuoteId('cameo', dbCameo.cameoId),
+    );
+  }
+
+  if (ERUDIT.config.public.sponsors?.enabled) {
+    const dbSponsors = await ERUDIT.db.query.sponsors.findMany({
+      columns: { sponsorId: true },
+      where: eq(ERUDIT.db.schema.sponsors.hasMessages, true),
+    });
+
+    if (dbSponsors.length > 0) {
+      ids.sponsor = dbSponsors.map((dbSponsor) =>
+        createQuoteId('sponsor', dbSponsor.sponsorId),
+      );
+    }
+  }
+
+  return ids;
+}