erudit 3.0.0-dev.4 → 3.0.0-dev.6

package/shared/bitran/link/target.ts

@@ -1,134 +1,134 @@
-import { isTopicPart } from 'erudit-cog/schema';
-import { tryReplaceAlias } from '@erudit-js/bitran-elements/aliases/shared';
-
-import type { BitranContext } from '@shared/bitran/context';
-import {
-    bitranLocationTypes,
-    parsePartialBitranLocation,
-    stringifyBitranLocation,
-} from '@shared/bitran/location';
-
-export type LinkTargetType = 'unique' | 'page' | 'absolute' | 'external';
-
-interface LinkTargetBase {
-    type: LinkTargetType;
-}
-
-export interface UniqueLinkTarget extends LinkTargetBase {
-    type: 'unique';
-    strlocation: string;
-    _productName?: string;
-    _absoluteStrLocation?: string;
-    _href?: string;
-}
-
-export const linkTargetPageTypes = {
-    ...bitranLocationTypes,
-    // Custom page types, that does not have Bitran content
-    book: true,
-};
-
-export type LinkTargetPageType = keyof typeof linkTargetPageTypes;
-
-export function isLinkTargetPageType(
-    pageType: any,
-): pageType is LinkTargetPageType {
-    return pageType in linkTargetPageTypes;
-}
-
-function pageTypeRequiresPath(type: LinkTargetPageType) {
-    return linkTargetPageTypes[type];
-}
-
-export interface PageLinkTarget extends LinkTargetBase {
-    type: 'page';
-    pageType: LinkTargetPageType;
-    path?: string;
-    _href?: string;
-}
-
-export interface AbsoluteLinkTarget extends LinkTargetBase {
-    type: 'absolute';
-    href: string;
-}
-
-export interface ExternalLinkTarget extends LinkTargetBase {
-    type: 'external';
-    href: string;
-}
-
-export type LinkTarget =
-    | UniqueLinkTarget
-    | PageLinkTarget
-    | AbsoluteLinkTarget
-    | ExternalLinkTarget;
-
-export function createLinkTarget(
-    target: string,
-    context: BitranContext,
-): LinkTarget {
-    target = tryReplaceAlias(target, context.aliases);
-
-    if (target.startsWith('/'))
-        return {
-            type: 'absolute',
-            href: target,
-        };
-
-    try {
-        new URL(target);
-        return {
-            type: 'external',
-            href: target,
-        };
-    } catch {}
-
-    if (target.startsWith('page|')) {
-        let [, pageType, path] = target.split('|');
-
-        if (!isLinkTargetPageType(pageType))
-            throw new Error(
-                `Unknown page type "${pageType}" in link "${target}"!`,
-            );
-
-        if (!path) {
-            if (isTopicPart(pageType)) {
-                if (!isTopicPart(context.location.type))
-                    throw new Error(
-                        `Page link "${target}" is referencing topic part "${pageType}" without path in non-topic context!`,
-                    );
-
-                path = context.location.path;
-            } else {
-                if (pageTypeRequiresPath(pageType))
-                    throw new Error(
-                        `Page link "${target}" does not have a path!`,
-                    );
-            }
-        }
-
-        return {
-            type: 'page',
-            pageType,
-            path,
-        };
-    }
-
-    const location = parsePartialBitranLocation(target, context.location);
-
-    if (
-        !location.unique &&
-        isLinkTargetPageType(location.type) &&
-        !isTopicPart(location.type)
-    )
-        return {
-            type: 'page',
-            pageType: location.type,
-            path: location.path,
-        };
-
-    return {
-        type: 'unique',
-        strlocation: stringifyBitranLocation(location),
-    };
-}
+import { isTopicPart } from '@erudit-js/cog/schema';
+import { tryReplaceAlias } from '@erudit-js/bitran-elements/aliases/shared';
+
+import type { BitranContext } from '@shared/bitran/context';
+import {
+    bitranLocationTypes,
+    parsePartialBitranLocation,
+    stringifyBitranLocation,
+} from '@shared/bitran/location';
+
+export type LinkTargetType = 'unique' | 'page' | 'absolute' | 'external';
+
+interface LinkTargetBase {
+    type: LinkTargetType;
+}
+
+export interface UniqueLinkTarget extends LinkTargetBase {
+    type: 'unique';
+    strlocation: string;
+    _productName?: string;
+    _absoluteStrLocation?: string;
+    _href?: string;
+}
+
+export const linkTargetPageTypes = {
+    ...bitranLocationTypes,
+    // Custom page types, that does not have Bitran content
+    book: true,
+};
+
+export type LinkTargetPageType = keyof typeof linkTargetPageTypes;
+
+export function isLinkTargetPageType(
+    pageType: any,
+): pageType is LinkTargetPageType {
+    return pageType in linkTargetPageTypes;
+}
+
+function pageTypeRequiresPath(type: LinkTargetPageType) {
+    return linkTargetPageTypes[type];
+}
+
+export interface PageLinkTarget extends LinkTargetBase {
+    type: 'page';
+    pageType: LinkTargetPageType;
+    path?: string;
+    _href?: string;
+}
+
+export interface AbsoluteLinkTarget extends LinkTargetBase {
+    type: 'absolute';
+    href: string;
+}
+
+export interface ExternalLinkTarget extends LinkTargetBase {
+    type: 'external';
+    href: string;
+}
+
+export type LinkTarget =
+    | UniqueLinkTarget
+    | PageLinkTarget
+    | AbsoluteLinkTarget
+    | ExternalLinkTarget;
+
+export function createLinkTarget(
+    target: string,
+    context: BitranContext,
+): LinkTarget {
+    target = tryReplaceAlias(target, context.aliases);
+
+    if (target.startsWith('/'))
+        return {
+            type: 'absolute',
+            href: target,
+        };
+
+    try {
+        new URL(target);
+        return {
+            type: 'external',
+            href: target,
+        };
+    } catch {}
+
+    if (target.startsWith('page|')) {
+        let [, pageType, path] = target.split('|');
+
+        if (!isLinkTargetPageType(pageType))
+            throw new Error(
+                `Unknown page type "${pageType}" in link "${target}"!`,
+            );
+
+        if (!path) {
+            if (isTopicPart(pageType)) {
+                if (!isTopicPart(context.location.type))
+                    throw new Error(
+                        `Page link "${target}" is referencing topic part "${pageType}" without path in non-topic context!`,
+                    );
+
+                path = context.location.path;
+            } else {
+                if (pageTypeRequiresPath(pageType))
+                    throw new Error(
+                        `Page link "${target}" does not have a path!`,
+                    );
+            }
+        }
+
+        return {
+            type: 'page',
+            pageType,
+            path,
+        };
+    }
+
+    const location = parsePartialBitranLocation(target, context.location);
+
+    if (
+        !location.unique &&
+        isLinkTargetPageType(location.type) &&
+        !isTopicPart(location.type)
+    )
+        return {
+            type: 'page',
+            pageType: location.type,
+            path: location.path,
+        };
+
+    return {
+        type: 'unique',
+        strlocation: stringifyBitranLocation(location),
+    };
+}

package/shared/bitran/link/transpiler.ts

@@ -1,10 +1,10 @@
-import { defineElementTranspiler } from '@bitran-js/transpiler';
-
-import { LinkNode, type LinkSchema } from './shared';
-import { LinkParser, LinkStringifier } from './factory';
-
-export const linkTranspiler = defineElementTranspiler<LinkSchema>({
-    Node: LinkNode,
-    Parsers: [LinkParser],
-    Stringifier: LinkStringifier,
-});
+import { defineElementTranspiler } from '@bitran-js/transpiler';
+
+import { LinkNode, type LinkSchema } from './shared';
+import { LinkParser, LinkStringifier } from './factory';
+
+export const linkTranspiler = defineElementTranspiler<LinkSchema>({
+    Node: LinkNode,
+    Parsers: [LinkParser],
+    Stringifier: LinkStringifier,
+});

package/shared/bitran/location.ts

@@ -1,166 +1,166 @@
-import { isTopicPart } from 'erudit-cog/schema';
-
-export const bitranLocationTypes = {
-    article: true,
-    summary: true,
-    practice: true,
-    group: true,
-    contributor: true,
-};
-
-export type BitranLocationType = keyof typeof bitranLocationTypes;
-
-export function isBitranLocationType(type: any): type is BitranLocationType {
-    return type in bitranLocationTypes;
-}
-
-function typeRequiresPath(type: BitranLocationType) {
-    return bitranLocationTypes[type];
-}
-
-export interface BitranLocation {
-    type: BitranLocationType;
-    path?: string;
-    unique?: string;
-}
-
-export function stringifyBitranLocation(location: BitranLocation): string {
-    try {
-        if (!isBitranLocationType(location.type))
-            throw `Unknown Bitran location type "${location.type}"!`;
-
-        if (!location.path && typeRequiresPath(location.type))
-            throw 'Missing Bitran location path!';
-
-        if (location.unique === '')
-            throw 'Bitran location unique cannot be empty string!';
-    } catch (reason) {
-        let message = `${reason}\n\n` + JSON.stringify(location, null, 4);
-        throw new Error(message);
-    }
-
-    return (
-        location.type +
-        '|' +
-        (location.path || '') +
-        (location.unique ? '|' + location.unique : '')
-    );
-}
-
-export function parseBitranLocation(strLocation: string): BitranLocation {
-    const [strType, strPath, strUnique] = strLocation.split('|');
-
-    if (!isBitranLocationType(strType))
-        throw new Error(`Unknown Bitran location type "${strType}"!`);
-
-    const location: BitranLocation = { type: strType };
-
-    if (!strPath) {
-        if (typeRequiresPath(location.type))
-            throw new Error(
-                `Missing Bitran location path for type "${strType}"!`,
-            );
-    } else location.path = strPath;
-
-    if (strUnique === '')
-        throw `Bitran location "${strLocation}" unique cannot be empty string!`;
-    else if (strUnique) location.unique = strUnique;
-
-    return location;
-}
-
-export function parsePartialBitranLocation(
-    strLocation: string,
-    contextLocation: BitranLocation,
-): BitranLocation {
-    const parts = strLocation.split('|');
-
-    // Only unique provided. Restoring type + path
-    // function -> article|foo/bar|function
-    if (parts.length === 1)
-        return {
-            type: contextLocation.type,
-            path: contextLocation.path,
-            unique: parts[0],
-        };
-
-    if (parts.length === 2) {
-        //
-        // If there are two parts, the result depends on location type
-        //
-
-        // In topics we can reference topic parts without specifying content path
-        // practice|function -> practice|foo/bar|function
-        if (isTopicPart(parts[0])) {
-            const [type, unique] = parts as [BitranLocationType, string];
-
-            if (!isTopicPart(contextLocation.type))
-                throw new Error(
-                    `String Bitran location "${strLocation}" referencing topic part "${type}" in non-topic context!`,
-                );
-
-            return {
-                type,
-                path: contextLocation.path,
-                unique,
-            };
-        }
-    }
-
-    return parseBitranLocation(strLocation);
-}
-
-export const { encodeBitranLocation, decodeBitranLocation } = (() => {
-    const encodeSymbols = {
-        '|': '┃',
-        '/': '╱',
-        ':': '﹕',
-    };
-
-    const decodeSymbols = Object.entries(encodeSymbols).reduce(
-        (map, [key, value]) => ((map[value] = key), map),
-        {} as Record<string, string>,
-    );
-
-    const replaceSymbols = (text: string, symbols: Record<string, string>) => {
-        for (const [find, replace] of Object.entries(symbols))
-            text = text.replaceAll(find, replace);
-
-        return text;
-    };
-
-    return {
-        encodeBitranLocation: (strLocation: string) =>
-            replaceSymbols(strLocation, encodeSymbols),
-
-        decodeBitranLocation: (strLocation: string) =>
-            replaceSymbols(strLocation, decodeSymbols),
-    };
-})();
-
-export function locationFromPath(routePath: string) {
-    const pathParts = (
-        routePath.startsWith('/') ? routePath.substring(1) : routePath
-    ).split('/');
-    const firstPart = pathParts.shift() as any;
-    const locationPath = pathParts.join('/');
-
-    if (!locationPath) return undefined;
-
-    if (isTopicPart(firstPart))
-        return {
-            type: firstPart,
-            path: locationPath,
-        };
-
-    switch (firstPart) {
-        case 'group':
-        case 'contributor':
-            return {
-                type: firstPart,
-                path: locationPath,
-            };
-    }
-
-    return undefined;
-}
+import { isTopicPart } from '@erudit-js/cog/schema';
+
+export const bitranLocationTypes = {
+    article: true,
+    summary: true,
+    practice: true,
+    group: true,
+    contributor: true,
+};
+
+export type BitranLocationType = keyof typeof bitranLocationTypes;
+
+export function isBitranLocationType(type: any): type is BitranLocationType {
+    return type in bitranLocationTypes;
+}
+
+function typeRequiresPath(type: BitranLocationType) {
+    return bitranLocationTypes[type];
+}
+
+export interface BitranLocation {
+    type: BitranLocationType;
+    path?: string;
+    unique?: string;
+}
+
+export function stringifyBitranLocation(location: BitranLocation): string {
+    try {
+        if (!isBitranLocationType(location.type))
+            throw `Unknown Bitran location type "${location.type}"!`;
+
+        if (!location.path && typeRequiresPath(location.type))
+            throw 'Missing Bitran location path!';
+
+        if (location.unique === '')
+            throw 'Bitran location unique cannot be empty string!';
+    } catch (reason) {
+        let message = `${reason}\n\n` + JSON.stringify(location, null, 4);
+        throw new Error(message);
+    }
+
+    return (
+        location.type +
+        '|' +
+        (location.path || '') +
+        (location.unique ? '|' + location.unique : '')
+    );
+}
+
+export function parseBitranLocation(strLocation: string): BitranLocation {
+    const [strType, strPath, strUnique] = strLocation.split('|');
+
+    if (!isBitranLocationType(strType))
+        throw new Error(`Unknown Bitran location type "${strType}"!`);
+
+    const location: BitranLocation = { type: strType };
+
+    if (!strPath) {
+        if (typeRequiresPath(location.type))
+            throw new Error(
+                `Missing Bitran location path for type "${strType}"!`,
+            );
+    } else location.path = strPath;
+
+    if (strUnique === '')
+        throw `Bitran location "${strLocation}" unique cannot be empty string!`;
+    else if (strUnique) location.unique = strUnique;
+
+    return location;
+}
+
+export function parsePartialBitranLocation(
+    strLocation: string,
+    contextLocation: BitranLocation,
+): BitranLocation {
+    const parts = strLocation.split('|');
+
+    // Only unique provided. Restoring type + path
+    // function -> article|foo/bar|function
+    if (parts.length === 1)
+        return {
+            type: contextLocation.type,
+            path: contextLocation.path,
+            unique: parts[0],
+        };
+
+    if (parts.length === 2) {
+        //
+        // If there are two parts, the result depends on location type
+        //
+
+        // In topics we can reference topic parts without specifying content path
+        // practice|function -> practice|foo/bar|function
+        if (isTopicPart(parts[0])) {
+            const [type, unique] = parts as [BitranLocationType, string];
+
+            if (!isTopicPart(contextLocation.type))
+                throw new Error(
+                    `String Bitran location "${strLocation}" referencing topic part "${type}" in non-topic context!`,
+                );
+
+            return {
+                type,
+                path: contextLocation.path,
+                unique,
+            };
+        }
+    }
+
+    return parseBitranLocation(strLocation);
+}
+
+export const { encodeBitranLocation, decodeBitranLocation } = (() => {
+    const encodeSymbols = {
+        '|': '┃',
+        '/': '╱',
+        ':': '﹕',
+    };
+
+    const decodeSymbols = Object.entries(encodeSymbols).reduce(
+        (map, [key, value]) => ((map[value] = key), map),
+        {} as Record<string, string>,
+    );
+
+    const replaceSymbols = (text: string, symbols: Record<string, string>) => {
+        for (const [find, replace] of Object.entries(symbols))
+            text = text.replaceAll(find, replace);
+
+        return text;
+    };
+
+    return {
+        encodeBitranLocation: (strLocation: string) =>
+            replaceSymbols(strLocation, encodeSymbols),
+
+        decodeBitranLocation: (strLocation: string) =>
+            replaceSymbols(strLocation, decodeSymbols),
+    };
+})();
+
+export function locationFromPath(routePath: string) {
+    const pathParts = (
+        routePath.startsWith('/') ? routePath.substring(1) : routePath
+    ).split('/');
+    const firstPart = pathParts.shift() as any;
+    const locationPath = pathParts.join('/');
+
+    if (!locationPath) return undefined;
+
+    if (isTopicPart(firstPart))
+        return {
+            type: firstPart,
+            path: locationPath,
+        };
+
+    switch (firstPart) {
+        case 'group':
+        case 'contributor':
+            return {
+                type: firstPart,
+                path: locationPath,
+            };
+    }
+
+    return undefined;
+}

package/shared/bitran/toc.ts

@@ -1,8 +1,8 @@
-export interface TocItem {
-    id: string;
-    level: number;
-    productName: string;
-    title?: string;
-}
-
-export type Toc = TocItem[];
+export interface TocItem {
+    id: string;
+    level: number;
+    productName: string;
+    title?: string;
+}
+
+export type Toc = TocItem[];

package/shared/content/context.ts

@@ -1,9 +1,9 @@
-export interface ContextItem {
-    type: string;
-    icon: string;
-    title: string;
-    href: string;
-    hidden: boolean;
-}
-
-export type Context = ContextItem[];
+export interface ContextItem {
+    type: string;
+    icon: string;
+    title: string;
+    href: string;
+    hidden: boolean;
+}
+
+export type Context = ContextItem[];