erudit 4.0.0-dev.3 → 4.0.0-dev.5

package/shared/types/runtimeConfig.ts

@@ -1,4 +1,3 @@
-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';
@@ -10,55 +9,38 @@ import type { EruditSiteFaviconResolved } from '@erudit-js/core/eruditConfig/sit
 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;
-    };
+  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;
+  language: EruditLanguage;
+  siteInfo: {
+    title?: string;
+    short?: string | false;
+    logotype?: string | false;
+    favicon?: EruditSiteFaviconResolved;
+    loadingSvg?: string;
+  };
+  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

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

package/shared/utils/contentTypePath.ts

@@ -2,62 +2,62 @@ 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;
+  type: 'book' | 'group' | 'page';
+  contentId: string;
 }
 
 interface TopicContentTypePath {
-    type: 'topic';
-    topicPart: TopicPart;
-    contentId: string;
+  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,
-        };
-    }
-
+  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: typeOrPart,
-        contentId: fullOrShortId,
+      type: 'topic',
+      topicPart: typeOrPart,
+      contentId: fullOrShortId,
     };
+  }
+
+  return {
+    type: typeOrPart,
+    contentId: fullOrShortId,
+  };
 }
 
 export function stringifyContentTypePath(
-    typeOrPart: Omit<ContentType | TopicPart, 'topic'>,
-    fullOrShortId: string,
+  typeOrPart: Omit<ContentType | TopicPart, 'topic'>,
+  fullOrShortId: string,
 ): string {
-    return `${typeOrPart}/${fullOrShortId}`;
+  return `${typeOrPart}/${fullOrShortId}`;
 }

package/shared/utils/icons.ts

@@ -1,11 +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',
+  ['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

@@ -1,24 +1,23 @@
+import { sn } from 'unslash';
 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 : ''}`,
-        );
-    },
+  index: '/',
+  contributors: '/contributors/',
+  contributor: (contributorId?: string) => {
+    return sn(`/contributor/${contributorId ?? ''}/`);
+  },
+  sponsors: '/sponsors/',
+  ['book']: (shortId: string) => {
+    return sn(`/book/${shortId}/`);
+  },
+  ['group']: (shortId: string) => {
+    return sn(`/group/${shortId}/`);
+  },
+  ['page']: (shortId: string, elementId?: string) => {
+    return sn(`/page/${shortId}/${elementId ? '#' + elementId : ''}`);
+  },
+  ['topic']: (part: TopicPart, shortId: string, elementId?: string) => {
+    return sn(`/${part}/${shortId}/${elementId ? '#' + elementId : ''}`);
+  },
 };

package/shared/utils/stringColor.ts

@@ -1,13 +1,13 @@
 export function stringColor(text: string) {
-    let hash = 0;
+  let hash = 0;
 
-    for (let i = 0; i < text.length; i++) {
-        hash = text.charCodeAt(i) + ((hash << 5) - hash);
-    }
+  for (let i = 0; i < text.length; i++) {
+    hash = text.charCodeAt(i) + ((hash << 5) - hash);
+  }
 
-    const hue = hash % 360;
-    const lightColor = `hsl(${hue}, 70%, 35%)`; // Darker for white background
-    const darkColor = `hsl(${hue}, 75%, 70%)`; // Lighter for black background
+  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})`;
+  return `light-dark(${lightColor}, ${darkColor})`;
 }

package/shared/utils/toStringEqual.ts

@@ -1,21 +1,21 @@
 function stringifyValue(value: unknown): string {
-    if (value === null || typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
 
-    if (Array.isArray(value)) {
-        return '[' + value.map(stringifyValue).join(',') + ']';
-    }
+  if (Array.isArray(value)) {
+    return '[' + value.map(stringifyValue).join(',') + ']';
+  }
 
-    const obj = value as Record<string, unknown>;
-    const keys = Object.keys(obj).sort();
-    const props = keys.map(
-        (k) => JSON.stringify(k) + ':' + stringifyValue(obj[k]),
-    );
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  const props = keys.map(
+    (k) => JSON.stringify(k) + ':' + stringifyValue(obj[k]),
+  );
 
-    return '{' + props.join(',') + '}';
+  return '{' + props.join(',') + '}';
 }
 
 export function toStringEqual(a: unknown, b: unknown): boolean {
-    return stringifyValue(a) === stringifyValue(b);
+  return stringifyValue(a) === stringifyValue(b);
 }

package/shared/utils/zip.ts

@@ -1,64 +1,64 @@
-export async function zip(text: string): Promise<string> {
-    const encoded = new TextEncoder().encode(text);
-    const compressedStream = new Blob([encoded.buffer as ArrayBuffer])
-        .stream()
-        .pipeThrough(new CompressionStream('gzip'));
-    const compressedBuffer = await new Response(compressedStream).arrayBuffer();
-
-    return toBase64(new Uint8Array(compressedBuffer));
-}
-
-export async function unzip(input: string): Promise<string> {
-    const gzBinary = fromBase64(input);
-    const decompressedStream = new Blob([gzBinary.buffer as ArrayBuffer])
-        .stream()
-        .pipeThrough(new DecompressionStream('gzip'));
-    const decompressedBuffer = await new Response(
-        decompressedStream,
-    ).arrayBuffer();
-
-    return new TextDecoder().decode(decompressedBuffer);
-}
-
-/**
- * Convert Uint8Array to base64 safely in both browser and Node.
- */
-function toBase64(bytes: Uint8Array): string {
-    if (typeof Buffer !== 'undefined') {
-        // Node environment
-        return Buffer.from(bytes).toString('base64');
-    }
-
-    if (typeof btoa !== 'undefined') {
-        // Browser environment
-        let binary = '';
-        const chunkSize = 0x8000;
-        for (let i = 0; i < bytes.length; i += chunkSize) {
-            binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
-        }
-        return btoa(binary);
-    }
-
-    throw new Error('No base64 encoding function available.');
-}
-
-/**
- * Convert base64 string to Uint8Array safely in both browser and Node.
- */
-function fromBase64(b64: string): Uint8Array {
-    if (typeof Buffer !== 'undefined') {
-        // Node environment
-        return new Uint8Array(Buffer.from(b64, 'base64'));
-    }
-
-    if (typeof atob !== 'undefined') {
-        // Browser environment
-        const binary = atob(b64);
-        const len = binary.length;
-        const out = new Uint8Array(len);
-        for (let i = 0; i < len; i++) out[i] = binary.charCodeAt(i);
-        return out;
-    }
-
-    throw new Error('No base64 decoding function available.');
-}
+export async function zip(text: string): Promise<string> {
+  const encoded = new TextEncoder().encode(text);
+  const compressedStream = new Blob([encoded.buffer as ArrayBuffer])
+    .stream()
+    .pipeThrough(new CompressionStream('gzip'));
+  const compressedBuffer = await new Response(compressedStream).arrayBuffer();
+
+  return toBase64(new Uint8Array(compressedBuffer));
+}
+
+export async function unzip(input: string): Promise<string> {
+  const gzBinary = fromBase64(input);
+  const decompressedStream = new Blob([gzBinary.buffer as ArrayBuffer])
+    .stream()
+    .pipeThrough(new DecompressionStream('gzip'));
+  const decompressedBuffer = await new Response(
+    decompressedStream,
+  ).arrayBuffer();
+
+  return new TextDecoder().decode(decompressedBuffer);
+}
+
+/**
+ * Convert Uint8Array to base64 safely in both browser and Node.
+ */
+function toBase64(bytes: Uint8Array): string {
+  if (typeof Buffer !== 'undefined') {
+    // Node environment
+    return Buffer.from(bytes).toString('base64');
+  }
+
+  if (typeof btoa !== 'undefined') {
+    // Browser environment
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+  }
+
+  throw new Error('No base64 encoding function available.');
+}
+
+/**
+ * Convert base64 string to Uint8Array safely in both browser and Node.
+ */
+function fromBase64(b64: string): Uint8Array {
+  if (typeof Buffer !== 'undefined') {
+    // Node environment
+    return new Uint8Array(Buffer.from(b64, 'base64'));
+  }
+
+  if (typeof atob !== 'undefined') {
+    // Browser environment
+    const binary = atob(b64);
+    const len = binary.length;
+    const out = new Uint8Array(len);
+    for (let i = 0; i < len; i++) out[i] = binary.charCodeAt(i);
+    return out;
+  }
+
+  throw new Error('No base64 decoding function available.');
+}

package/test/shared/utils/zip.test.ts

@@ -1,8 +1,8 @@
-import { test, expect } from 'vitest';
-
-import { zip, unzip } from '../../../shared/utils/zip';
-
-test('zip/unzip', async () => {
-    const text = 'Hello мир 🌍!';
-    expect(await unzip(await zip(text))).toBe(text);
-});
+import { test, expect } from 'vitest';
+
+import { zip, unzip } from '../../../shared/utils/zip';
+
+test('zip/unzip', async () => {
+  const text = 'Hello мир 🌍!';
+  expect(await unzip(await zip(text))).toBe(text);
+});

package/tsconfig.json

@@ -1,17 +1,17 @@
 {
-    "files": [],
-    "references": [
-        {
-            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.server.json"
-        },
-        {
-            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.app.json"
-        },
-        {
-            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.shared.json"
-        },
-        {
-            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.node.json"
-        }
-    ]
+  "files": [],
+  "references": [
+    {
+      "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.app.json"
+    },
+    {
+      "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.server.json"
+    },
+    {
+      "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.shared.json"
+    },
+    {
+      "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.node.json"
+    }
+  ]
 }

package/bin/erudit.mjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '@erudit-js/cli/cli';

package/modules/erudit/setup/aliases.ts

@@ -1,17 +0,0 @@
-import type { Nuxt } from '@nuxt/schema';
-
-import type { EruditRuntimeConfig } from '../../../shared/types/runtimeConfig';
-
-export async function setupEruditAliases(
-    nuxt: Nuxt,
-    runtimeConfig: EruditRuntimeConfig,
-) {
-    nuxt.options.alias = {
-        ...nuxt.options.alias,
-        '@erudit': runtimeConfig.paths.package,
-        '@erudit/module': runtimeConfig.paths.module,
-        '@erudit/app': runtimeConfig.paths.app,
-        '@erudit/server': runtimeConfig.paths.server,
-        $: runtimeConfig.paths.app + '/styles',
-    };
-}

package/modules/erudit/setup/baseUrl.ts

@@ -1,19 +0,0 @@
-import type { Nuxt } from '@nuxt/schema';
-import { updateTemplates } from 'nuxt/kit';
-
-import type { EruditPublicRuntimeConfig } from '../../../shared/types/runtimeConfig';
-
-export async function setupEruditCustomBaseUrl(
-    nuxt: Nuxt,
-    publicRuntimeConfig: EruditPublicRuntimeConfig,
-) {
-    const newBaseUrl = publicRuntimeConfig.project.baseUrl;
-
-    if (newBaseUrl === '/') {
-        return;
-    }
-
-    nuxt.options.app.baseURL = newBaseUrl;
-    nuxt.options.nitro.runtimeConfig!.app!.baseURL = newBaseUrl;
-    await updateTemplates();
-}