tycho-components 0.22.6 → 0.23.0

package/dist/configs/index.d.ts

@@ -25,3 +25,5 @@ export { useCorpusUtils } from './useCorpusUtils';
 export { useLoggedUtils } from './useLoggedUtils';
 export { useMessageUtils } from './useMessageUtils';
 export { useTourUtils } from './useTourUtils';
+export { useDriverTour, loadKnowledgeBase, defaultMatchPathnames, buildAnchorMap, flattenWorkflowSteps, getWorkflowsForPath, buildDriveSteps, createTourDriver, hasMatchingWorkflow, resolveAnchor, resolveAnchorById, waitForSelector, } from './tour';
+export type { AnchorSelector, KnowledgeBase, PopoverSide, ResolveKnowledgeBaseUrl, TourAnchor, TourButtonLabels, TourStep, TourWorkflow, UseDriverTourOptions, } from './tour';

package/dist/configs/index.js

@@ -14,3 +14,4 @@ export { useCorpusUtils } from './useCorpusUtils';
 export { useLoggedUtils } from './useLoggedUtils';
 export { useMessageUtils } from './useMessageUtils';
 export { useTourUtils } from './useTourUtils';
+export { useDriverTour, loadKnowledgeBase, defaultMatchPathnames, buildAnchorMap, flattenWorkflowSteps, getWorkflowsForPath, buildDriveSteps, createTourDriver, hasMatchingWorkflow, resolveAnchor, resolveAnchorById, waitForSelector, } from './tour';

package/dist/configs/tour/anchorResolver.d.ts

@@ -0,0 +1,4 @@
+import type { AnchorSelector, TourAnchor } from './types';
+export declare function resolveAnchor(anchor: TourAnchor, anchorFallbacks?: Record<string, AnchorSelector>): Element | null;
+export declare function resolveAnchorById(anchorId: string, anchorMap: Map<string, TourAnchor>, anchorFallbacks?: Record<string, AnchorSelector>): Element | null;
+export declare function waitForSelector(selector: string, timeoutMs?: number, intervalMs?: number): Promise<Element | null>;

package/dist/configs/tour/anchorResolver.js

@@ -0,0 +1,91 @@
+const INTERACTIVE_SELECTOR = 'button, a[href], [role="button"], .ds-button, .ds-icon-button, input[type="button"], input[type="submit"]';
+function normalizeText(value) {
+    return value.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+function resolveCssSelector(selector) {
+    try {
+        return document.querySelector(selector);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveAriaSelector(label) {
+    const byAria = document.querySelector(`[aria-label="${label}"]`);
+    if (byAria)
+        return byAria;
+    const byTitle = document.querySelector(`[title="${label}"]`);
+    if (byTitle)
+        return byTitle;
+    const normalizedLabel = normalizeText(label);
+    const candidates = document.querySelectorAll(INTERACTIVE_SELECTOR);
+    for (const candidate of candidates) {
+        const aria = candidate.getAttribute('aria-label');
+        const title = candidate.getAttribute('title');
+        if ((aria && normalizeText(aria) === normalizedLabel) ||
+            (title && normalizeText(title) === normalizedLabel)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveTextSelector(expected, mode) {
+    const normalizedExpected = normalizeText(expected);
+    const candidates = document.querySelectorAll(INTERACTIVE_SELECTOR);
+    for (const candidate of candidates) {
+        const text = normalizeText(candidate.textContent ?? '');
+        const matches = mode === 'exact'
+            ? text === normalizedExpected
+            : text.startsWith(normalizedExpected);
+        if (matches)
+            return candidate;
+    }
+    return null;
+}
+function resolveSelector(selector) {
+    if (selector.startsWith('aria:')) {
+        return resolveAriaSelector(selector.slice(5));
+    }
+    if (selector.startsWith('textPrefix:')) {
+        return resolveTextSelector(selector.slice(11), 'prefix');
+    }
+    if (selector.startsWith('text:')) {
+        return resolveTextSelector(selector.slice(5), 'exact');
+    }
+    return resolveCssSelector(selector);
+}
+function resolveSelectorList(selectors) {
+    const list = Array.isArray(selectors) ? selectors : [selectors];
+    for (const selector of list) {
+        const element = resolveSelector(selector);
+        if (element)
+            return element;
+    }
+    return null;
+}
+export function resolveAnchor(anchor, anchorFallbacks) {
+    const element = resolveSelectorList(anchor.selector);
+    if (element)
+        return element;
+    const fallback = anchorFallbacks?.[anchor.id];
+    if (fallback) {
+        return resolveSelectorList(fallback);
+    }
+    return null;
+}
+export function resolveAnchorById(anchorId, anchorMap, anchorFallbacks) {
+    const anchor = anchorMap.get(anchorId);
+    if (!anchor)
+        return null;
+    return resolveAnchor(anchor, anchorFallbacks);
+}
+export async function waitForSelector(selector, timeoutMs = 10000, intervalMs = 100) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const element = resolveCssSelector(selector);
+        if (element)
+            return element;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return null;
+}

package/dist/configs/tour/driverTour.d.ts

@@ -0,0 +1,5 @@
+import { type DriveStep, type Driver } from 'driver.js';
+import type { AnchorSelector, KnowledgeBase, TourAnchor, TourButtonLabels } from './types';
+export declare function buildDriveSteps(kb: KnowledgeBase, pathnames: string | string[], anchorFallbacks?: Record<string, AnchorSelector>): DriveStep[];
+export declare function hasMatchingWorkflow(kb: KnowledgeBase, pathnames: string | string[]): boolean;
+export declare function createTourDriver(labels: TourButtonLabels, onDestroyed: () => void, anchorMap: Map<string, TourAnchor>, anchorFallbacks?: Record<string, AnchorSelector>): Driver;

package/dist/configs/tour/driverTour.js

@@ -0,0 +1,143 @@
+import { driver } from 'driver.js';
+import { resolveAnchor, resolveAnchorById, waitForSelector, } from './anchorResolver';
+import { buildAnchorMap, flattenWorkflowSteps, getWorkflowsForPath, } from './knowledgeBase';
+const CLICK_DEMO_DELAY_MS = 300;
+function isPanelOpen(panelSelector) {
+    return Boolean(document.querySelector(panelSelector));
+}
+function clickElement(element) {
+    if (element instanceof HTMLElement)
+        element.click();
+}
+function closePanel(anchor, anchorMap, anchorFallbacks) {
+    const panelSelector = anchor.panelSelector;
+    if (!panelSelector || !isPanelOpen(panelSelector))
+        return;
+    if (anchor.closeSelector) {
+        clickElement(document.querySelector(anchor.closeSelector) ?? undefined);
+        return;
+    }
+    if (anchor.triggerAnchor) {
+        clickElement(resolveAnchorById(anchor.triggerAnchor, anchorMap, anchorFallbacks) ??
+            undefined);
+    }
+}
+function findPanelAnchor(panelSelector, anchorMap) {
+    return [...anchorMap.values()].find((a) => a.panelSelector === panelSelector);
+}
+function closeGuardPanel(guardClickPanel, anchorMap, anchorFallbacks) {
+    if (!guardClickPanel || !isPanelOpen(guardClickPanel))
+        return;
+    const panelAnchor = findPanelAnchor(guardClickPanel, anchorMap);
+    if (panelAnchor) {
+        closePanel(panelAnchor, anchorMap, anchorFallbacks);
+    }
+}
+function closeOpenPanels(anchorMap, anchorFallbacks) {
+    for (const anchor of anchorMap.values()) {
+        if (anchor.panelSelector && isPanelOpen(anchor.panelSelector)) {
+            closePanel(anchor, anchorMap, anchorFallbacks);
+        }
+    }
+}
+function chainPopoverClick(driveStep, key, beforeAdvance, advance) {
+    const popover = driveStep.popover ?? {};
+    const existing = popover[key];
+    const handler = (element, step, opts) => {
+        beforeAdvance();
+        if (existing) {
+            existing(element, step, opts);
+        }
+        else {
+            advance(opts);
+        }
+    };
+    driveStep.popover = {
+        ...popover,
+        [key]: handler,
+    };
+}
+function attachClickDemoHooks(driveStep, anchor, anchorMap, anchorFallbacks) {
+    driveStep.onHighlighted = (element, _step, opts) => {
+        window.setTimeout(() => {
+            if (anchor.guardClickPanel && isPanelOpen(anchor.guardClickPanel)) {
+                return;
+            }
+            clickElement(element);
+            opts.driver.refresh();
+        }, CLICK_DEMO_DELAY_MS);
+    };
+    chainPopoverClick(driveStep, 'onPrevClick', () => closeGuardPanel(anchor.guardClickPanel, anchorMap, anchorFallbacks), (opts) => opts.driver.movePrevious());
+}
+function attachPanelStepHooks(driveStep, anchor, anchorMap, anchorFallbacks) {
+    const { panelSelector, triggerAnchor } = anchor;
+    if (!panelSelector || !triggerAnchor)
+        return;
+    driveStep.element = () => resolveAnchor(anchor, anchorFallbacks);
+    driveStep.onHighlightStarted = async (_element, _step, opts) => {
+        if (!isPanelOpen(panelSelector)) {
+            clickElement(resolveAnchorById(triggerAnchor, anchorMap, anchorFallbacks) ?? undefined);
+        }
+        await waitForSelector(panelSelector);
+        opts.driver.refresh();
+    };
+    const close = () => closePanel(anchor, anchorMap, anchorFallbacks);
+    chainPopoverClick(driveStep, 'onNextClick', close, (opts) => opts.driver.moveNext());
+    chainPopoverClick(driveStep, 'onPrevClick', close, (opts) => opts.driver.movePrevious());
+}
+export function buildDriveSteps(kb, pathnames, anchorFallbacks) {
+    const workflows = getWorkflowsForPath(kb, pathnames);
+    const steps = flattenWorkflowSteps(workflows);
+    const anchorMap = buildAnchorMap(kb);
+    return steps.map((step) => {
+        const driveStep = {
+            popover: {
+                title: step.title,
+                description: step.body,
+            },
+        };
+        if (step.anchor) {
+            const anchor = anchorMap.get(step.anchor);
+            if (!anchor)
+                return driveStep;
+            if (anchor.resolveAtHighlight) {
+                attachPanelStepHooks(driveStep, anchor, anchorMap, anchorFallbacks);
+            }
+            else {
+                const element = resolveAnchorById(step.anchor, anchorMap, anchorFallbacks);
+                if (element) {
+                    driveStep.element = element;
+                    if (anchor.click) {
+                        attachClickDemoHooks(driveStep, anchor, anchorMap, anchorFallbacks);
+                    }
+                }
+            }
+            if (anchor.popoverSide) {
+                driveStep.popover = {
+                    ...driveStep.popover,
+                    side: anchor.popoverSide,
+                };
+            }
+        }
+        return driveStep;
+    });
+}
+export function hasMatchingWorkflow(kb, pathnames) {
+    return getWorkflowsForPath(kb, pathnames).length > 0;
+}
+export function createTourDriver(labels, onDestroyed, anchorMap, anchorFallbacks) {
+    return driver({
+        showProgress: true,
+        allowClose: true,
+        smoothScroll: true,
+        overlayOpacity: 0.5,
+        popoverClass: 'tycho-tour-popover',
+        nextBtnText: labels.next,
+        prevBtnText: labels.previous,
+        doneBtnText: labels.done,
+        onDestroyed: () => {
+            closeOpenPanels(anchorMap, anchorFallbacks);
+            onDestroyed();
+        },
+    });
+}

package/dist/configs/tour/index.d.ts

@@ -0,0 +1,5 @@
+export { useDriverTour } from './useDriverTour';
+export { buildAnchorMap, defaultMatchPathnames, flattenWorkflowSteps, getWorkflowsForPath, loadKnowledgeBase, } from './knowledgeBase';
+export { buildDriveSteps, createTourDriver, hasMatchingWorkflow, } from './driverTour';
+export { resolveAnchor, resolveAnchorById, waitForSelector, } from './anchorResolver';
+export type { AnchorSelector, KnowledgeBase, PopoverSide, ResolveKnowledgeBaseUrl, TourAnchor, TourButtonLabels, TourStep, TourWorkflow, UseDriverTourOptions, } from './types';

package/dist/configs/tour/index.js

@@ -0,0 +1,4 @@
+export { useDriverTour } from './useDriverTour';
+export { buildAnchorMap, defaultMatchPathnames, flattenWorkflowSteps, getWorkflowsForPath, loadKnowledgeBase, } from './knowledgeBase';
+export { buildDriveSteps, createTourDriver, hasMatchingWorkflow, } from './driverTour';
+export { resolveAnchor, resolveAnchorById, waitForSelector, } from './anchorResolver';

package/dist/configs/tour/knowledgeBase.d.ts

@@ -0,0 +1,6 @@
+import type { KnowledgeBase, TourAnchor, TourStep, TourWorkflow } from './types';
+export declare function loadKnowledgeBase(url: string): Promise<KnowledgeBase>;
+export declare function defaultMatchPathnames(routerPathname: string): string[];
+export declare function getWorkflowsForPath(kb: KnowledgeBase, pathname: string | string[]): TourWorkflow[];
+export declare function flattenWorkflowSteps(workflows: TourWorkflow[]): TourStep[];
+export declare function buildAnchorMap(kb: KnowledgeBase): Map<string, TourAnchor>;

package/dist/configs/tour/knowledgeBase.js

@@ -0,0 +1,50 @@
+const cachedByUrl = new Map();
+const loadPromiseByUrl = new Map();
+export async function loadKnowledgeBase(url) {
+    const cached = cachedByUrl.get(url);
+    if (cached)
+        return cached;
+    const existingPromise = loadPromiseByUrl.get(url);
+    if (existingPromise)
+        return existingPromise;
+    const loadPromise = fetch(url)
+        .then((response) => {
+        if (!response.ok) {
+            throw new Error(`Failed to load tour knowledge base (${response.status})`);
+        }
+        return response.json();
+    })
+        .then((data) => {
+        cachedByUrl.set(url, data);
+        return data;
+    })
+        .catch((error) => {
+        loadPromiseByUrl.delete(url);
+        throw error;
+    });
+    loadPromiseByUrl.set(url, loadPromise);
+    return loadPromise;
+}
+export function defaultMatchPathnames(routerPathname) {
+    const windowPath = window.location.pathname;
+    const trimmed = windowPath.length > 1 && windowPath.endsWith('/')
+        ? windowPath.slice(0, -1)
+        : windowPath;
+    const candidates = new Set([
+        windowPath,
+        trimmed,
+        `${trimmed}/`,
+        routerPathname,
+    ]);
+    return [...candidates];
+}
+export function getWorkflowsForPath(kb, pathname) {
+    const pathnames = Array.isArray(pathname) ? pathname : [pathname];
+    return kb.workflows.filter((workflow) => pathnames.some((p) => new RegExp(workflow.matchRoute).test(p)));
+}
+export function flattenWorkflowSteps(workflows) {
+    return workflows.flatMap((workflow) => workflow.steps);
+}
+export function buildAnchorMap(kb) {
+    return new Map(kb.anchors.map((anchor) => [anchor.id, anchor]));
+}

package/dist/configs/tour/style.scss

@@ -0,0 +1,22 @@
+@import 'driver.js/dist/driver.css';
+
+.driver-popover.tycho-tour-popover {
+  max-width: 500px;
+  padding: 32px 32px 16px;
+
+  .driver-popover-title {
+    @include subtitle-small-2;
+    color: var(--text-primary);
+  }
+
+  .driver-popover-description {
+    @include body-medium-1;
+    color: var(--text-secondary);
+    margin-top: 16px;
+  }
+
+  .driver-popover-footer button {
+    @include label-medium-1;
+    text-shadow: none;
+  }
+}

package/dist/configs/tour/types.d.ts

@@ -0,0 +1,45 @@
+export type AnchorSelector = string | string[];
+export type PopoverSide = 'top' | 'right' | 'bottom' | 'left';
+export type TourAnchor = {
+    id: string;
+    selector: AnchorSelector;
+    intent?: string;
+    needsAddedTo?: string;
+    click?: boolean;
+    resolveAtHighlight?: boolean;
+    triggerAnchor?: string;
+    panelSelector?: string;
+    closeSelector?: string;
+    guardClickPanel?: string;
+    popoverSide?: PopoverSide;
+};
+export type TourStep = {
+    title: string;
+    body: string;
+    anchor?: string;
+};
+export type TourWorkflow = {
+    id: string;
+    title: string;
+    matchRoute: string;
+    steps: TourStep[];
+};
+export type KnowledgeBase = {
+    title: string;
+    module: string;
+    anchors: TourAnchor[];
+    workflows: TourWorkflow[];
+};
+export type TourButtonLabels = {
+    next: string;
+    previous: string;
+    done: string;
+};
+export type ResolveKnowledgeBaseUrl = () => string | Promise<string>;
+export type UseDriverTourOptions = {
+    resolveKnowledgeBaseUrl: ResolveKnowledgeBaseUrl;
+    reloadDeps?: readonly unknown[];
+    anchorFallbacks?: Record<string, AnchorSelector>;
+    getMatchPathnames?: (pathname: string) => string[];
+    waitForSelector?: string;
+};

package/dist/configs/tour/types.js

@@ -0,0 +1 @@
+export {};

package/dist/configs/tour/useDriverTour.d.ts

@@ -0,0 +1,2 @@
+import type { UseDriverTourOptions } from './types';
+export declare function useDriverTour(options: UseDriverTourOptions): void;

package/dist/configs/tour/useDriverTour.js

@@ -0,0 +1,95 @@
+import { useContext, useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useLocation } from 'react-router-dom';
+import CommonContext from '../CommonContext';
+import Storage from '../Storage';
+import { useTourUtils } from '../useTourUtils';
+import { waitForSelector } from './anchorResolver';
+import { buildDriveSteps, createTourDriver, hasMatchingWorkflow, } from './driverTour';
+import { buildAnchorMap, defaultMatchPathnames, loadKnowledgeBase, } from './knowledgeBase';
+export function useDriverTour(options) {
+    const { state } = useContext(CommonContext);
+    const { turnOn, turnOff } = useTourUtils();
+    const { t } = useTranslation('common');
+    const { pathname } = useLocation();
+    const [knowledgeBase, setKnowledgeBase] = useState(null);
+    const driverRef = useRef(null);
+    const autoOpenTriggered = useRef(false);
+    const turnOffRef = useRef(turnOff);
+    const labelsRef = useRef({ next: '', previous: '', done: '' });
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    turnOffRef.current = turnOff;
+    labelsRef.current = {
+        next: t('button.next'),
+        previous: t('button.back'),
+        done: t('button.close'),
+    };
+    useEffect(() => {
+        let cancelled = false;
+        const load = async () => {
+            const resolvedUrl = await optionsRef.current.resolveKnowledgeBaseUrl();
+            if (cancelled)
+                return;
+            try {
+                const kb = await loadKnowledgeBase(resolvedUrl);
+                if (!cancelled)
+                    setKnowledgeBase(kb);
+            }
+            catch (error) {
+                console.error(error);
+                if (!cancelled)
+                    setKnowledgeBase(null);
+            }
+        };
+        setKnowledgeBase(null);
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [pathname, options.resolveKnowledgeBaseUrl, options.reloadDeps]);
+    useEffect(() => {
+        if (!knowledgeBase || autoOpenTriggered.current)
+            return;
+        const matchPathnames = (optionsRef.current.getMatchPathnames ?? defaultMatchPathnames)(pathname);
+        if (!Storage.getTourAutoOpen() ||
+            !hasMatchingWorkflow(knowledgeBase, matchPathnames)) {
+            return;
+        }
+        autoOpenTriggered.current = true;
+        turnOn();
+    }, [knowledgeBase, pathname, turnOn]);
+    useEffect(() => {
+        if (!state.tour || !knowledgeBase)
+            return;
+        let cancelled = false;
+        const matchPathnames = (optionsRef.current.getMatchPathnames ?? defaultMatchPathnames)(pathname);
+        if (!hasMatchingWorkflow(knowledgeBase, matchPathnames)) {
+            turnOffRef.current();
+            return;
+        }
+        const startTour = async () => {
+            const { waitForSelector: startSelector, anchorFallbacks } = optionsRef.current;
+            if (startSelector) {
+                await waitForSelector(startSelector);
+            }
+            if (cancelled)
+                return;
+            driverRef.current?.destroy();
+            const anchorMap = buildAnchorMap(knowledgeBase);
+            const driverObj = createTourDriver(labelsRef.current, () => turnOffRef.current(), anchorMap, anchorFallbacks);
+            driverRef.current = driverObj;
+            driverObj.setSteps(buildDriveSteps(knowledgeBase, matchPathnames, anchorFallbacks));
+            driverObj.drive(0);
+        };
+        startTour().catch((error) => {
+            console.error(error);
+            turnOffRef.current();
+        });
+        return () => {
+            cancelled = true;
+            driverRef.current?.destroy();
+            driverRef.current = null;
+        };
+    }, [state.tour, knowledgeBase, pathname]);
+}

package/dist/features/DocumentDrawer/DocumentExport/DocumentExport.js

@@ -58,14 +58,14 @@ export default function DocumentExport({ doc }) {
         });
     };
     const handleExportClick = (type) => {
-        if (type === 'TXT') {
+        if (type === 'TEXT') {
             setOpenTxtTierModal(true);
             return;
         }
         process(type);
     };
     const handleTxtTierSelect = (tier) => {
-        process('TXT', tier);
+        process('TEXT', tier);
     };
     const handleError = (err) => {
         const message = err.response.data.message || err.response.data.error;

package/dist/features/DocumentDrawer/localization/ExportTexts.d.ts

@@ -11,8 +11,6 @@ export declare const ExportTexts: {
         'export.desc.csv': string;
         'export.label.text': string;
         'export.desc.text': string;
-        'export.label.txt': string;
-        'export.desc.txt': string;
         'modal.title.txt.tier': string;
         'modal.desc.txt.tier': string;
         'modal.txt.tier.diplomatic': string;
@@ -37,8 +35,6 @@ export declare const ExportTexts: {
         'export.desc.csv': string;
         'export.label.text': string;
         'export.desc.text': string;
-        'export.label.txt': string;
-        'export.desc.txt': string;
         'modal.title.txt.tier': string;
         'modal.desc.txt.tier': string;
         'modal.txt.tier.diplomatic': string;
@@ -63,8 +59,6 @@ export declare const ExportTexts: {
         'export.desc.csv': string;
         'export.label.text': string;
         'export.desc.text': string;
-        'export.label.txt': string;
-        'export.desc.txt': string;
         'modal.title.txt.tier': string;
         'modal.desc.txt.tier': string;
         'modal.txt.tier.diplomatic': string;

package/dist/features/DocumentDrawer/localization/ExportTexts.js

@@ -10,9 +10,7 @@ export const ExportTexts = {
         'export.label.csv': 'CSV',
         'export.desc.csv': 'Generates a text file with comma separated values (CSV), ready to be imported to Microsoft Excel.',
         'export.label.text': 'Text file',
-        'export.desc.text': 'Text file',
-        'export.label.txt': 'Text file',
-        'export.desc.txt': 'Generates a plain text file with the document sentences at the chosen transcription layer.',
+        'export.desc.text': 'Generates a plain text file with the document sentences at the chosen transcription layer.',
         'modal.title.txt.tier': 'Choose export type',
         'modal.desc.txt.tier': 'Select which transcription layer to use for the text export.',
         'modal.txt.tier.diplomatic': 'Diplomatic',
@@ -36,9 +34,7 @@ export const ExportTexts = {
         'export.label.csv': 'CSV',
         'export.desc.csv': 'Gera um arquivo de texto com valores separados por vírgula (CSV), pronto para ser importado para o Microsoft Excel.',
         'export.label.text': 'Arquivo de texto',
-        'export.desc.text': 'Arquivo de texto',
-        'export.label.txt': 'Arquivo de texto',
-        'export.desc.txt': 'Gera um arquivo de texto simples com as sentenças do documento na camada de transcrição escolhida.',
+        'export.desc.text': 'Gera um arquivo de texto simples com as sentenças do documento na camada de transcrição escolhida.',
         'modal.title.txt.tier': 'Escolha o tipo de exportação',
         'modal.desc.txt.tier': 'Selecione qual camada de transcrição usar na exportação de texto.',
         'modal.txt.tier.diplomatic': 'Diplomática',
@@ -62,9 +58,7 @@ export const ExportTexts = {
         'export.label.csv': 'CSV',
         'export.desc.csv': 'Genera un file di testo con valori separati da virgola (CSV), pronto per essere importato in Microsoft Excel.',
         'export.label.text': 'File di testo',
-        'export.desc.text': 'File di testo',
-        'export.label.txt': 'File di testo',
-        'export.desc.txt': 'Genera un file di testo semplice con le frasi del documento al livello di trascrizione scelto.',
+        'export.desc.text': 'Genera un file di testo semplice con le frasi del documento al livello di trascrizione scelto.',
         'modal.title.txt.tier': 'Scegli il tipo di esportazione',
         'modal.desc.txt.tier': 'Seleziona quale livello di trascrizione usare per l\'esportazione del testo.',
         'modal.txt.tier.diplomatic': 'Diplomatica',

package/dist/features/DocumentDrawer/types/Export.d.ts

@@ -1,10 +1,10 @@
-export type ExportType = 'TYCHO' | 'PSD' | 'CSV' | 'POS' | 'TXT' | 'CHAT' | 'CONLLU';
+export type ExportType = 'TYCHO' | 'PSD' | 'CSV' | 'POS' | 'TEXT' | 'CHAT' | 'CONLLU';
 export declare const ExportTypeNames: {
     TYCHO: string;
     PSD: string;
     CSV: string;
     POS: string;
-    TXT: string;
+    TEXT: string;
     CHAT: string;
     CONLLU: string;
 };

package/dist/features/DocumentDrawer/types/Export.js

@@ -3,7 +3,7 @@ export const ExportTypeNames = {
     PSD: 'export.type.psd',
     CSV: 'export.type.csv',
     POS: 'export.type.pos',
-    TXT: 'export.type.text',
+    TEXT: 'export.type.text',
     CHAT: 'export.type.chat',
     CONLLU: 'export.type.conllu',
 };
@@ -34,7 +34,7 @@ export const EXPORT_TYPE_DISPLAY = [
         active: true,
     },
     {
-        type: 'TXT',
+        type: 'TEXT',
         icon: 'description',
         active: true,
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.22.6",
+  "version": "0.23.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -40,7 +40,8 @@
       "import": "./dist/cytoscape-context-menus.js",
       "require": "./dist/cytoscape-context-menus.js"
     },
-    "./dist/styles/main": "./dist/styles/main.scss"
+    "./dist/styles/main": "./dist/styles/main.scss",
+    "./dist/configs/tour/style.scss": "./dist/configs/tour/style.scss"
   },
   "files": [
     "dist/"
@@ -54,6 +55,7 @@
     "cytoscape-dagre": "^2.5.0",
     "cytoscape-node-html-label": "^1.2.2",
     "date-fns": "^4.1.0",
+    "driver.js": "^1.4.0",
     "date-fns-tz": "^3.2.0",
     "file-saver": "^2.0.5",
     "html2canvas": "^1.4.1",