erudit 3.0.0-dev.3 → 3.0.0-dev.30

package/shared/types/language.ts

@@ -1,75 +1,189 @@
-export interface EruditPhrases {
-    _language_title: string;
-    _language_code: string;
+import type { EruditLanguageCode } from '@erudit-js/core/eruditConfig/language';
 
-    site_info_title: string;
-    site_info_slogan: string;
-    seo_index_title: string;
-    seo_index_description: string;
-    seo_article_description: (contentTitle: string) => string;
-    seo_summary_description: (contentTitle: string) => string;
-    seo_practice_description: (contentTitle: string) => string;
-    index: string;
+export type LanguageCode = EruditLanguageCode;
+export type LanguagePhraseKey = keyof LanguagePhrases;
+export type LanguagePhraseValue = string | ((...args: any[]) => string);
+export type PayloadLanguagePhraseValue =
+    | { type: 'missing' }
+    | { type: 'string'; value: string }
+    | { type: 'function'; value: string };
+
+export type LanguagePhrases = Phrases<{
+    language_code: string;
+    language_name: string;
+    erudit: string;
+    content_nav: string;
     pages: string;
     search: string;
-    language: string;
-    other: string;
-    ads_replacer: string;
+    languages: string;
+    settings: string;
     theme: string;
-    theme_system: string;
     theme_light: string;
     theme_dark: string;
+    theme_system: string;
+    built: string;
     content: string;
-    generator: string;
-    main_page: string;
-    members: string;
     add_translation: string;
-    empty_nav: string;
-    flag_dev: string;
-    flag_dev_description: string;
-    flag_advanced: string;
-    flag_advanced_description: string;
-    flag_secondary: string;
-    flag_secondary_description: string;
-    popover_dependencies: string;
-    popover_dependencies_description: string;
+    main_page: string;
+    contributors: string;
+    sponsors: string;
+    search_the_site: string;
+    searching_more: string;
+    no_results: string;
+    no_more_results: string;
+    no_content: string;
     to_index: string;
-    about_book: string;
-    close: string;
-    back: string;
-    goto: string;
-    error: string;
-    external_link: string;
-    external_link_warn: string;
-    internal_link: string;
-    internal_link_warn: string;
+    about_textbook: string;
+    flag_title_dev: string;
+    flag_hint_dev: string;
+    flag_title_advanced: string;
+    flag_hint_advanced: string;
+    flag_title_secondary: string;
+    flag_hint_secondary: string;
+    ads_replacer: string;
+    direct_link: string;
+    direct_link_explain: string;
     book: string;
     group: string;
     topic: string;
     article: string;
     summary: string;
     practice: string;
-    contributor: string;
-    element_id: string;
-    preview_missing_title: string;
-    preview_missing_explain: string;
-    preview_missing_explain_mismatch: string;
-    preview_hash_mismatch_title: string;
-    preview_hash_mismatch_explain: string;
-    current_page_hash: string;
-    expected_page_hash: string;
-    empty_toc: string;
-    contributors: string;
+    page: string;
+    preview_content_page_description: string;
+    begin_learning: string;
+    flag_dev: string;
+    flag_dev_description: string;
+    flag_advanced: string;
+    flag_advanced_description: string;
+    flag_secondary: string;
+    flag_secondary_description: string;
+    key_elements: string;
+    stats: string;
+    connections: string;
+    need_to_know: string;
+    depends_on: string;
+    used_by: string;
+    externals: string;
+    add_quote: string;
+    next_quote: string;
+    sponsors_description: string;
+    become_sponsor: string;
+    no_sponsors: string;
+    contributors_description: string;
+    contributors_invite: string;
+    contributor_page_description: (name: string) => string;
+    become_contributor: string;
     no_contributors: string;
+    contribution: string;
+    no_contribution: string;
+    editor: string;
+    materials: string;
+    x_sponsors: (count: number) => string;
+    x_contributors: (count: number) => string;
+    news: string;
+    no_news: string;
+    show_more: string;
     make_contribution: string;
-    material_improvement: string;
+    improve_material: string;
     how_to_improve: string;
+    report_issue: string;
     edit_page: string;
-    report_problem: string;
-    references: string;
-    reference_source_featured: string;
-    references_description: string;
-}
+    no_toc: string;
+    article_seo_description: (contentTitle: string) => string;
+    summary_seo_description: (contentTitle: string) => string;
+    practice_seo_description: (contentTitle: string) => string;
+
+    default_index_title: string;
+    default_index_short: string;
+    default_site_info_short: string;
+
+    // _language_title: string;
+    // _language_code: string;
+    // site_info_title: string;
+    // site_info_slogan: string;
+    // seo_index_title: string;
+    // seo_index_description: string;
+    // seo_article_description: (contentTitle: string) => string;
+    // seo_summary_description: (contentTitle: string) => string;
+    // seo_practice_description: (contentTitle: string) => string;
+    // index: string;
+    // pages: string;
+    // search: string;
+    // language: string;
+    // other: string;
+    // ads_replacer: string;
+    // theme: string;
+    // theme_system: string;
+    // theme_light: string;
+    // theme_dark: string;
+    // content: string;
+    // main_page: string;
+    // contributors: string;
+    // contributors_page_description: string;
+    // contributors_page_invite: string;
+    // become_contributor: string;
+    // contributor: string;
+    // contribution: string;
+    // contributions_explain: (count: number) => string;
+    // contributor_description: (name: string) => string;
+    // editor: string;
+    // add_translation: string;
+    // empty_nav: string;
+    // flag_dev: string;
+    // flag_dev_description: string;
+    // flag_advanced: string;
+    // flag_advanced_description: string;
+    // flag_secondary: string;
+    // flag_secondary_description: string;
+    // popover_dependencies: string;
+    // popover_dependencies_description: string;
+    // close: string;
+    // back: string;
+    // goto: string;
+    // error: string;
+    // external_link: string;
+    // external_link_warn: string;
+    // internal_link: string;
+    // internal_link_warn: string;
+    // book: string;
+    // group: string;
+    // topic: string;
+    // topics: string;
+    // article: string;
+    // summary: string;
+    // practice: string;
+    // element_id: string;
+    // preview_missing_title: string;
+    // preview_missing_explain: string;
+    // preview_missing_explain_mismatch: string;
+    // preview_hash_mismatch_title: string;
+    // preview_hash_mismatch_explain: string;
+    // current_page_hash: string;
+    // expected_page_hash: string;
+    // empty_toc: string;
+    // no_contributors: string;
+    // make_contribution: string;
+    // material_improvement: string;
+    // how_to_improve: string;
+    // edit_page: string;
+    // report_problem: string;
+    // references: string;
+    // reference_source_featured: string;
+    // references_description: string;
+    // sponsors: string;
+    // sponsors_description: string;
+    // become_sponsor: string;
+    // toc: string;
+    // mentions: (conte: number) => string;
+    // start_learning: string;
+    // x_contributors: (count: number) => string;
+    // x_sponsors: (count: number) => string;
+    // show_all: string;
+}>;
+
+//
+// Utility types for type safety
+//
 
-export type EruditPhraseId = keyof Partial<EruditPhrases>;
-export type EruditPhrase = EruditPhrases[keyof EruditPhrases];
+type Phrases<T extends Record<string, LanguagePhraseValue>> = T;

package/shared/types/mainContent.ts

@@ -0,0 +1,69 @@
+import type { FinalizedProse } from '@jsprose/core';
+import type { ContentType } from '@erudit-js/core/content/type';
+import type { TopicPart } from '@erudit-js/core/content/topic';
+import type { ContentFlags } from '@erudit-js/core/content/flags';
+import type { ContentContribution } from '@erudit-js/core/content/contributions';
+import type { ResolvedTocItem } from '@erudit-js/prose';
+import type { ContentSeo } from '@erudit-js/core/content/seo';
+
+export interface MainContentBase {
+    type: ContentType;
+    breadcrumbs: Breadcrumbs;
+    fullId: string;
+    shortId: string;
+    contentRelativePath: string;
+    title: string;
+    bookTitle?: string;
+    description?: string;
+    decoration?: string;
+    flags?: ContentFlags;
+    stats?: ContentStats;
+    connections?: ContentConnections;
+    contributions?: ContentContribution[];
+    seo?: ContentSeo;
+}
+
+export interface MainContentChildrenItem {
+    type: ContentType;
+    link: string;
+    title: string;
+    description?: string;
+    quickLinks?: ElementSnippet[];
+    stats?: ContentStats;
+}
+
+//
+//
+//
+
+export type MainContentTopicPart = MainContentBase &
+    FinalizedProse & {
+        type: 'topic';
+        part: TopicPart;
+        parts: TopicPart[];
+        snippets?: ElementSnippet[];
+        toc?: ResolvedTocItem[];
+    };
+
+export type MainContentPage = MainContentBase &
+    FinalizedProse & {
+        type: 'page';
+        snippets?: ElementSnippet[];
+        toc?: ResolvedTocItem[];
+    };
+
+export type MainContentGroup = MainContentBase & {
+    type: 'group';
+    children: MainContentChildrenItem[];
+};
+
+export type MainContentBook = MainContentBase & {
+    type: 'book';
+    children: MainContentChildrenItem[];
+};
+
+export type MainContent =
+    | MainContentTopicPart
+    | MainContentPage
+    | MainContentGroup
+    | MainContentBook;

package/shared/types/news.ts

@@ -0,0 +1,13 @@
+import type { FinalizedProse } from '@jsprose/core';
+
+export interface NewsBatch {
+    items: NewsItem[];
+    nextIndex?: number;
+    /** Only present in the first batch with index 0! */
+    total?: number;
+}
+
+export interface NewsItem {
+    date: string;
+    content: FinalizedProse;
+}

package/shared/types/preview.ts

@@ -0,0 +1,28 @@
+import type { FinalizedProse } from '@jsprose/core';
+import type { PreviewRequest } from '@erudit-js/core/preview/request';
+import type { ContentType } from '@erudit-js/core/content/type';
+
+export type PreviewState = {
+    opened: boolean;
+    request: PreviewRequest | undefined;
+    history: PreviewRequest[];
+    blink: number;
+};
+
+export type PreviewContentPage = {
+    content:
+        | { type: 'topic'; topicPart: string }
+        | { type: Exclude<ContentType, 'topic'> };
+    title: string;
+    description?: string;
+    bookTitle?: string;
+    link: string;
+};
+
+export type PreviewContentUnique = {
+    link: string;
+    contentTitle: string;
+    elementTitle?: string;
+    schemaName: string;
+    fadeOverlay?: boolean;
+} & FinalizedProse;

package/shared/types/runtimeConfig.ts

@@ -0,0 +1,64 @@
+import type { EruditMode } from '@erudit-js/core/mode';
+import type { EruditAdsBanners } from '@erudit-js/core/eruditConfig/ads';
+import type { EruditLanguage } from '@erudit-js/core/eruditConfig/language';
+import type { EruditCustomLinks } from '@erudit-js/core/eruditConfig/links';
+import type { EruditRepository } from '@erudit-js/core/eruditConfig/repository';
+import type { EruditSponsors } from '@erudit-js/core/sponsor';
+import type { EruditContributors } from '@erudit-js/core/contributor';
+import type { EruditIndexPage } from '@erudit-js/core/eruditConfig/indexPage';
+import type { EruditSiteFaviconResolved } from '@erudit-js/core/eruditConfig/site';
+import type { EruditSeo } from '@erudit-js/core/eruditConfig/seo';
+import type { EruditAnalytics } from '@erudit-js/core/eruditConfig/analytics';
+
+export interface EruditRuntimeConfigPaths {
+    package: string;
+    module: string;
+    app: string;
+    server: string;
+    project: string;
+    build: string;
+}
+
+export interface EruditRuntimeConfig {
+    paths: EruditRuntimeConfigPaths;
+    project: {
+        elements: string[];
+        countElements: (string | string[])[];
+        indexPage?: EruditIndexPage;
+    };
+}
+
+export interface EruditPublicRuntimeConfig {
+    mode: EruditMode;
+    version: string;
+    project: {
+        language: EruditLanguage;
+        originUrl: string;
+        baseUrl: string;
+        siteInfo: {
+            title?: string;
+            short?: string | false;
+            logotype?: string | false;
+            favicon?: EruditSiteFaviconResolved;
+        };
+        seo?: EruditSeo;
+        debug: {
+            log: boolean;
+            slowTransition: boolean;
+            ads: boolean;
+            fakeApi: {
+                repository: boolean;
+            };
+            analytics?: boolean;
+        };
+        repository?: EruditRepository & { _link: string };
+        style?: {
+            brandColor?: string;
+        };
+        customLinks?: EruditCustomLinks;
+        contributors?: EruditContributors;
+        sponsors?: EruditSponsors;
+        ads?: EruditAdsBanners;
+        analytics?: EruditAnalytics;
+    };
+}

package/shared/types/search.ts

@@ -0,0 +1,79 @@
+//
+// Commands
+//
+
+import type { MaybeMyIconName } from '#my-icons';
+
+export interface SearchCommandInit {
+    type: 'init';
+    baseUrl: string;
+    cacheId: string;
+    language: LanguageCode;
+}
+
+export interface SearchCommandSearch {
+    type: 'search';
+    id: number;
+    query: string;
+}
+
+export interface SearchCommandMore {
+    type: 'more';
+    id: number; // added: identify which search to paginate
+}
+
+export type SearchCommand =
+    | SearchCommandInit
+    | SearchCommandSearch
+    | SearchCommandMore;
+
+//
+// Responses
+//
+
+export interface SearchResponseError {
+    type: 'error';
+    message: string;
+}
+
+export interface SearchResponseResults {
+    type: 'results';
+    entries: SearchEntry[];
+    hasMore: boolean;
+}
+
+export type SearchResponse = SearchResponseError | SearchResponseResults;
+
+//
+//
+//
+
+export interface SearchStatusVariant {
+    id: string;
+    icon?: MaybeMyIconName;
+    message?: string;
+}
+
+export interface SearchEntry {
+    category: string;
+    title: string;
+    link: string;
+    description?: string;
+    synonyms?: string[];
+    location?: string;
+}
+
+export type ResolvedSearchEntry = SearchEntry & {
+    id: number;
+    categoryPriority: number;
+};
+
+export interface SearchEntryCategory {
+    id: string;
+    priority: number;
+}
+
+export interface SearchEntriesList {
+    category: SearchEntryCategory;
+    entries: SearchEntry[];
+}

package/shared/utils/contentTypePath.ts

@@ -0,0 +1,63 @@
+import { type TopicPart, isTopicPart } from '@erudit-js/core/content/topic';
+import { type ContentType, isContentType } from '@erudit-js/core/content/type';
+
+interface OtherContentTypePath {
+    type: 'book' | 'group' | 'page';
+    contentId: string;
+}
+
+interface TopicContentTypePath {
+    type: 'topic';
+    topicPart: TopicPart;
+    contentId: string;
+}
+
+export type ContentTypePath = OtherContentTypePath | TopicContentTypePath;
+
+export function parseContentTypePath(contentPath: string): ContentTypePath {
+    const contentPathArray = contentPath.split('/');
+    const typeOrPart = contentPathArray.shift();
+
+    if (!isTopicPart(typeOrPart) && !isContentType(typeOrPart)) {
+        throw createError({
+            status: 400,
+            statusMessage: `Invalid content path type/topic part: "${contentPath}"!`,
+        });
+    }
+
+    if (typeOrPart === 'topic') {
+        throw createError({
+            status: 400,
+            statusMessage: `Instead of "topic", use specific topic part (article, summary or practice) in content path: "${contentPath}"!`,
+        });
+    }
+
+    const fullOrShortId = contentPathArray.join('/');
+
+    if (!fullOrShortId) {
+        throw createError({
+            status: 400,
+            statusMessage: `Falsy content path full/short ID: "${contentPath}"!`,
+        });
+    }
+
+    if (isTopicPart(typeOrPart)) {
+        return {
+            type: 'topic',
+            topicPart: typeOrPart,
+            contentId: fullOrShortId,
+        };
+    }
+
+    return {
+        type: typeOrPart,
+        contentId: fullOrShortId,
+    };
+}
+
+export function stringifyContentTypePath(
+    typeOrPart: Omit<ContentType | TopicPart, 'topic'>,
+    fullOrShortId: string,
+): string {
+    return `${typeOrPart}/${fullOrShortId}`;
+}

package/shared/utils/icons.ts

@@ -0,0 +1,11 @@
+import type { MaybeMyIconName } from '#my-icons';
+
+export const ICONS = {
+    ['book']: 'book-outline',
+    ['group']: 'folder-open',
+    ['page']: 'lines',
+    ['topic']: 'array-lines',
+    ['article']: 'array-lines',
+    ['summary']: 'array-star',
+    ['practice']: 'array-check',
+} satisfies Record<string, MaybeMyIconName>;

package/shared/utils/pages.ts

@@ -0,0 +1,24 @@
+import type { TopicPart } from '@erudit-js/core/content/topic';
+
+export const PAGES = {
+    index: '/',
+    contributors: '/contributors/',
+    contributor: (contributorId?: string) => {
+        return slasher(`/contributor/${contributorId ?? ''}/`);
+    },
+    sponsors: '/sponsors/',
+    ['book']: (shortId: string) => {
+        return slasher(`/book/${shortId}/`);
+    },
+    ['group']: (shortId: string) => {
+        return slasher(`/group/${shortId}/`);
+    },
+    ['page']: (shortId: string, elementId?: string) => {
+        return slasher(`/page/${shortId}/${elementId ? '#' + elementId : ''}`);
+    },
+    ['topic']: (part: TopicPart, shortId: string, elementId?: string) => {
+        return slasher(
+            `/${part}/${shortId}/${elementId ? '#' + elementId : ''}`,
+        );
+    },
+};

package/shared/utils/slasher.ts

@@ -0,0 +1,64 @@
+interface SlasherOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    dedupe?: boolean;
+    toForward?: boolean;
+}
+
+export function slasher(str: string, options: SlasherOptions = {}): string {
+    const opts: Required<Pick<SlasherOptions, 'toForward' | 'dedupe'>> &
+        SlasherOptions = {
+        toForward: true,
+        dedupe: true,
+        ...options,
+    };
+
+    let s = str ?? '';
+
+    // Normalize slashes direction
+    if (opts.toForward) {
+        s = s.replace(/\\/g, '/');
+    }
+
+    // Collapse runs of slashes, but preserve protocol double slashes (http://, https://, file://)
+    if (opts.dedupe) {
+        // Temporarily replace protocols to protect them
+        const protocolPlaceholder = '\x00PROTOCOL\x00';
+        const protocols: string[] = [];
+
+        s = s.replace(/(https?|file):\/\//g, (match) => {
+            protocols.push(match);
+            return protocolPlaceholder;
+        });
+
+        // Now dedupe slashes
+        s = s.replace(/\/{2,}/g, '/');
+
+        // Restore protocols
+        s = s.replace(
+            new RegExp(
+                protocolPlaceholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+                'g',
+            ),
+            () => protocols.shift()!,
+        );
+    }
+
+    // Leading slash handling
+    if (options?.leading === true) {
+        s = s.replace(/^\/+/, '');
+        s = '/' + s;
+    } else if (options?.leading === false) {
+        s = s.replace(/^\/+/, '');
+    }
+
+    // Trailing slash handling
+    if (options?.trailing === true) {
+        s = s.replace(/\/+$/, '');
+        s = s + '/';
+    } else if (options?.trailing === false) {
+        s = s.replace(/\/+$/, '');
+    }
+
+    return s;
+}

package/shared/utils/stringColor.ts

@@ -5,5 +5,9 @@ export function stringColor(text: string) {
         hash = text.charCodeAt(i) + ((hash << 5) - hash);
     }
 
-    return `hsl(${hash % 360}, 85%, 35%)`;
+    const hue = hash % 360;
+    const lightColor = `hsl(${hue}, 70%, 35%)`; // Darker for white background
+    const darkColor = `hsl(${hue}, 75%, 70%)`; // Lighter for black background
+
+    return `light-dark(${lightColor}, ${darkColor})`;
 }