@parhelia/localization 0.1.10745

package/dist/localization/src/steps/ServiceLanguageSelectionStep.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from "react";
+// Version creation now offered via VersionOnlyTranslationProvider. No custom button here.
+export function ServiceLanguageSelectionStep({ data, setData, onStepCompleted, editContext, setFooterActions, requestClose }) {
+    const [languageSelection, setLanguageSelection] = useState({});
+    const dataRef = useRef(data);
+    useEffect(() => { dataRef.current = data; }, [data]);
+    // Check if multi-item translation is enabled
+    const multiItemEnabled = editContext?.configuration?.localization?.multiItem !== false;
+    // Use a ref to avoid dependency on onStepCompleted
+    const onStepCompletedRef = useRef(onStepCompleted);
+    useEffect(() => {
+        onStepCompletedRef.current = onStepCompleted;
+    }, [onStepCompleted]);
+    useEffect(() => {
+        const hasProvider = !!data.translationProvider;
+        const hasLanguages = data.targetLanguages.length > 0;
+        onStepCompletedRef.current(hasProvider && hasLanguages);
+    }, [data.translationProvider, data.targetLanguages.length]);
+    // 1) Derive provider + available languages (lightweight, in-memory)
+    const provider = useMemo(() => data.translationProviders.find(p => p.name === data.translationProvider), [data.translationProviders, data.translationProvider]);
+    const siteLanguageCodes = useMemo(() => Array.from(data.languageData.keys()), [data.languageData]);
+    const availableLanguageCodes = useMemo(() => (provider?.supportedLanguages?.length ? provider.supportedLanguages : siteLanguageCodes), [provider?.supportedLanguages, siteLanguageCodes]);
+    const allLanguages = useMemo(() => {
+        const arr = availableLanguageCodes
+            .map(code => ({
+            code,
+            name: data.languageData.get(code)?.name || code,
+            hasVersions: (data.languageData.get(code)?.items.length || 0) > 0,
+            translationStatus: data.languageData.get(code)?.translationStatus,
+        }))
+            // Exclude languages where the provider/source language equals the language itself
+            // e.g., if sourceLanguage is 'en', don't allow translating to 'en'
+            .filter(lang => !lang.translationStatus || lang.translationStatus.sourceLanguage !== lang.code);
+        arr.sort((a, b) => a.name.localeCompare(b.name));
+        return arr;
+    }, [availableLanguageCodes, data.languageData]);
+    // Rehydrate UI selection from saved wizard data when returning to this step
+    useEffect(() => {
+        if (!allLanguages || allLanguages.length === 0)
+            return;
+        const initialSelection = {};
+        // Mark as selected any language that's in our saved targetLanguages array
+        for (const langCode of data.targetLanguages) {
+            const lang = allLanguages.find(l => l.code === langCode);
+            if (lang) {
+                initialSelection[langCode] = true;
+            }
+        }
+        setLanguageSelection(initialSelection);
+    }, [allLanguages, data.targetLanguages]);
+    // Update wizard data when language selection changes
+    useEffect(() => {
+        const selectedLanguages = Object.entries(languageSelection)
+            .filter(([, isSelected]) => isSelected)
+            .map(([code]) => code);
+        // Only update if the selection has actually changed
+        if (JSON.stringify(selectedLanguages.sort()) !== JSON.stringify(data.targetLanguages.sort())) {
+            const newData = {
+                ...data,
+                targetLanguages: selectedLanguages
+            };
+            setData(newData);
+        }
+    }, [languageSelection]);
+    const handleProviderChange = (e) => {
+        const newProvider = e.target.value;
+        const newData = {
+            ...data,
+            translationProvider: newProvider,
+            // Clear target languages when provider changes since language availability might change
+            targetLanguages: []
+        };
+        setData(newData);
+        // Clear UI selection too
+        setLanguageSelection({});
+    };
+    const handleLanguageToggle = (langCode) => {
+        setLanguageSelection(prev => ({ ...prev, [langCode]: !prev[langCode] }));
+    };
+    const handleSubitemsToggle = () => {
+        const newData = {
+            ...data,
+            includeSubitems: !data.includeSubitems
+        };
+        setData(newData);
+    };
+    return (_jsxs("div", { className: "p-6 space-y-6 h-full flex flex-col", "data-testid": "service-language-selection-step", children: [_jsxs("div", { children: [_jsx("h2", { className: "text-xl font-semibold mb-2", children: "Configure Translation" }), _jsx("p", { className: "text-sm text-gray-600 mb-6", children: "Select translation provider and target languages for your content." })] }), _jsxs("div", { className: "space-y-6 flex-1", children: [_jsxs("div", { children: [_jsx("h3", { className: "text-sm font-medium text-gray-900 mb-2", children: "Translation Provider" }), _jsx("p", { className: "text-xs text-gray-600 mb-3", children: "Choose how to translate your content. \"Create Versions\" will create new language versions without automatic translation." }), _jsxs("select", { value: data.translationProvider || "", onChange: handleProviderChange, className: "block w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-blue-500 focus:border-blue-500 sm:text-sm", "data-testid": "translation-provider-select", children: [_jsx("option", { value: "", disabled: true, children: "Select a provider..." }), data.translationProviders.map((provider) => (_jsx("option", { value: provider.name, children: provider.displayName }, provider.name)))] })] }), multiItemEnabled && (_jsxs("div", { children: [_jsxs("label", { className: "flex items-center", children: [_jsx("input", { type: "checkbox", checked: data.includeSubitems, onChange: handleSubitemsToggle, className: "h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 rounded", "data-testid": "include-subitems-checkbox" }), _jsx("span", { className: "ml-2 text-sm text-gray-900", children: "Include subitems" })] }), _jsx("p", { className: "text-xs text-gray-500 mt-1 ml-6", children: "Also translate any child components and nested content within this item." })] })), _jsxs("div", { children: [_jsx("h3", { className: "text-sm font-medium text-gray-900 mb-2", children: "Target Languages" }), _jsx("p", { className: "text-xs text-gray-600 mb-3", children: "Select the languages you want to translate this content into." }), _jsx("div", { className: "border border-gray-200 rounded-md min-h-[200px] max-h-64 overflow-y-auto", children: data.translationProviders.length === 0 || allLanguages.length === 0 ? (
+                                // Loading skeleton
+                                _jsx("div", { className: "p-3 space-y-2", children: [...Array(4)].map((_, i) => (_jsxs("div", { className: "flex items-center animate-pulse", children: [_jsx("div", { className: "h-4 w-4 bg-gray-200 rounded" }), _jsx("div", { className: "ml-2 h-4 bg-gray-200 rounded w-32" }), _jsx("div", { className: "ml-auto h-4 bg-gray-200 rounded w-16" })] }, i))) })) : (_jsx("div", { className: "p-3 grid grid-cols-1 gap-2", children: allLanguages.map((lang) => (_jsxs("label", { className: "flex items-center", children: [_jsx("input", { type: "checkbox", checked: languageSelection[lang.code] || false, onChange: () => handleLanguageToggle(lang.code), className: "h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 rounded", "data-testid": `language-checkbox-${lang.code}` }), _jsxs("span", { className: "ml-2 text-sm text-gray-900", children: [lang.name, " (", lang.code, ")"] }), !lang.hasVersions && (_jsx("span", { className: "ml-auto text-xs text-orange-600 bg-orange-100 px-2 py-1 rounded", children: "No versions" }))] }, lang.code))) })) })] })] })] }));
+}

package/dist/localization/src/steps/SubitemDiscoveryStep.d.ts

@@ -0,0 +1,3 @@
+import { TranslationStepProps } from "./types";
+export declare function SubitemDiscoveryStep({ data, setData, editContext, onStepCompleted, setBeforeNextCallback, setFooterActions, requestClose }: TranslationStepProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SubitemDiscoveryStep.d.ts.map

package/dist/localization/src/steps/SubitemDiscoveryStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubitemDiscoveryStep.d.ts","sourceRoot":"","sources":["../../../../src/steps/SubitemDiscoveryStep.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAY/C,wBAAgB,oBAAoB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,YAAY,EAAE,EAAE,oBAAoB,2CAyfhK"}

package/dist/localization/src/steps/SubitemDiscoveryStep.js

@@ -0,0 +1,391 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState, useRef, useMemo, useCallback } from "react";
+import { Button } from "@parhelia/core";
+// Custom tree implementation (no rc-tree)
+// NOTE: import PerfectTree from core package via dist path to avoid TS path issues in local package builds
+import { PerfectTree } from "../../../core/src/editor/ui/PerfectTree";
+import { convertFullItemToStub, convertStubToFullItem } from "@parhelia/core";
+import { discoverItemsTree, convertBackendTreeToTreeNodes, flattenPagesFromBackendTrees } from "../api/discovery";
+// We need to implement a basic Spinner component since it's not in core
+const Spinner = ({ ...props }) => (_jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-blue-600", ...props }));
+export function SubitemDiscoveryStep({ data, setData, editContext, onStepCompleted, setBeforeNextCallback, setFooterActions, requestClose }) {
+    const [isDiscovering, setIsDiscovering] = useState(false);
+    const [discoveredCount, setDiscoveredCount] = useState(0);
+    const [cancelled, setCancelled] = useState(false);
+    const [discoveryComplete, setDiscoveryComplete] = useState(false);
+    const [subitemsFound, setSubitemsFound] = useState(0);
+    const [selectedItemIds, setSelectedItemIds] = useState(new Set());
+    const [treeNodes, setTreeNodes] = useState([]);
+    const [allDiscoveredItems, setAllDiscoveredItems] = useState([]);
+    // Once the user interacts with selection, stop auto-selecting
+    const [userSelectionOverride, setUserSelectionOverride] = useState(false);
+    // Expanded state for custom tree
+    const [expandedIds, setExpandedIds] = useState(new Set());
+    // Track when tree structure is fully built and ready for display
+    const [treeInitialized, setTreeInitialized] = useState(false);
+    const cancelledRef = useRef(false);
+    const discoveredItemsRef = useRef([]);
+    const processedItemIds = useRef(new Set());
+    const dataRef = useRef(data);
+    // Track if initialization is complete to prevent reacting to selection changes during setup
+    const [initializationComplete, setInitializationComplete] = useState(false);
+    // Keep data ref updated
+    useEffect(() => {
+        dataRef.current = data;
+    }, [data]);
+    const contTokenRef = useRef(null);
+    const inFlightRef = useRef(false);
+    const aggregatedRef = useRef([]);
+    const backendTreesRef = useRef([]);
+    const shiftToggleRef = useRef(false);
+    const selectedItemIdsRef = useRef(new Set());
+    const allDiscoveredItemsRef = useRef([]);
+    const hasRegisteredBeforeNextRef = useRef(false);
+    // Track the last initialized item IDs to prevent re-initialization with same data
+    const lastInitializedItemIdsRef = useRef('');
+    const startDiscovery = useCallback(async () => {
+        if (inFlightRef.current)
+            return; // guard double-trigger (StrictMode, re-renders)
+        inFlightRef.current = true;
+        setIsDiscovering(true);
+        setCancelled(false);
+        setDiscoveryComplete(false);
+        // Only reset when starting fresh (no continuation token)
+        if (!contTokenRef.current) {
+            setAllDiscoveredItems([]);
+            setTreeNodes([]);
+            setTreeInitialized(false);
+            aggregatedRef.current = [];
+        }
+        cancelledRef.current = false;
+        const rootIds = data.items.map(i => i.descriptor.id);
+        try {
+            while (!cancelledRef.current) {
+                // Use new backend tree endpoint in one shot
+                const resp = await discoverItemsTree({
+                    rootItemIds: rootIds,
+                    language: editContext?.contentEditorItem?.language || "en",
+                }, editContext.sessionId ?? undefined);
+                const pages = flattenPagesFromBackendTrees(resp.trees);
+                aggregatedRef.current = pages;
+                backendTreesRef.current = resp.trees;
+                setDiscoveredCount(pages.length);
+                setSubitemsFound(Math.max(0, pages.length - data.items.length));
+                break;
+            }
+            if (!cancelledRef.current) {
+                setIsDiscovering(false);
+                setDiscoveryComplete(true);
+                // Keep a flat list of discovered pages for selection summary/commit
+                const stubs = aggregatedRef.current.map(x => ({
+                    id: x.id,
+                    name: x.name,
+                    path: x.path,
+                    parentId: "",
+                    idPath: "",
+                    database: "master",
+                    descriptor: { id: x.id, language: editContext?.contentEditorItem?.language || "en", version: 0 },
+                    icon: "",
+                    largeIcon: "",
+                    templateId: "",
+                    templateName: "",
+                    hasLayout: false,
+                    hasChildren: x.hasChildren,
+                    versions: 0,
+                    language: editContext?.contentEditorItem?.language || "en",
+                    version: 0,
+                }));
+                setAllDiscoveredItems(stubs);
+                const nodes = convertBackendTreeToTreeNodes(backendTreesRef.current);
+                setTreeNodes(nodes);
+                setExpandedIds(new Set(nodes.map(n => n.key)));
+                setTreeInitialized(true);
+            }
+        }
+        catch (error) {
+            console.error("Error during discovery:", error);
+            setIsDiscovering(false);
+        }
+        finally {
+            inFlightRef.current = false;
+        }
+    }, [data.items, editContext]);
+    // Initialize discovery state when component mounts or input items change
+    useEffect(() => {
+        const convertedItems = data.items.map(convertFullItemToStub);
+        // Create a stable key from item IDs and includeSubitems flag to detect actual changes
+        const itemKey = convertedItems.map(i => i.id).sort().join(',') + ':' + data.includeSubitems;
+        // Skip re-initialization if we've already initialized with these exact items
+        if (lastInitializedItemIdsRef.current === itemKey) {
+            return;
+        }
+        console.log('🔄 Initializing SubitemDiscoveryStep with items:', itemKey);
+        lastInitializedItemIdsRef.current = itemKey;
+        discoveredItemsRef.current = convertedItems;
+        // Don't set allDiscoveredItems until discovery is complete
+        setDiscoveredCount(data.items.length);
+        processedItemIds.current = new Set(); // Start empty - items should be processed to find children
+        // Auto-select original items
+        if (!userSelectionOverride) {
+            setSelectedItemIds(new Set(convertedItems.map(item => item.id)));
+        }
+        // Trigger discovery after state updates
+        if (data.includeSubitems && convertedItems.some(item => item.hasChildren)) {
+            // Clear any existing tree data before starting discovery
+            setAllDiscoveredItems([]);
+            setTreeNodes([]);
+            setTreeInitialized(false);
+            setDiscoveryComplete(false);
+            setTimeout(() => startDiscovery(), 0);
+        }
+        else {
+            // No discovery needed, show items immediately
+            setAllDiscoveredItems(convertedItems);
+            setDiscoveryComplete(true);
+            // Build tree structure
+            const nodes = buildTreeNodes(convertedItems);
+            setTreeNodes(nodes);
+            // Expand all root nodes by default
+            const rootNodeIds = nodes.map(node => node.key);
+            setExpandedIds(new Set(rootNodeIds));
+            // Mark tree as fully initialized
+            setTreeInitialized(true);
+        }
+        // Mark initialization as complete after all setup is done
+        setInitializationComplete(true);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [data.items, data.includeSubitems]);
+    // Keep refs in sync without causing parent rerenders
+    useEffect(() => { selectedItemIdsRef.current = selectedItemIds; }, [selectedItemIds]);
+    useEffect(() => { allDiscoveredItemsRef.current = allDiscoveredItems; }, [allDiscoveredItems]);
+    // Register the commit callback ONCE to avoid parent rerender on first selection
+    useEffect(() => {
+        if (!setBeforeNextCallback || hasRegisteredBeforeNextRef.current)
+            return;
+        const commit = async () => {
+            const selectedIds = selectedItemIdsRef.current;
+            const allStubs = allDiscoveredItemsRef.current;
+            const selectedItems = allStubs.filter(item => selectedIds.has(item.id));
+            const convertedItems = selectedItems.map(convertStubToFullItem);
+            const currentData = dataRef.current;
+            if (JSON.stringify(currentData.discoveredItems) !== JSON.stringify(convertedItems)) {
+                setData({ ...currentData, discoveredItems: convertedItems });
+            }
+            return true;
+        };
+        setBeforeNextCallback(commit);
+        hasRegisteredBeforeNextRef.current = true;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [setBeforeNextCallback]);
+    // Use a ref to avoid dependency on onStepCompleted
+    const onStepCompletedRef = useRef(onStepCompleted);
+    useEffect(() => {
+        onStepCompletedRef.current = onStepCompleted;
+    }, [onStepCompleted]);
+    // Update step completion based on selection
+    // Mark completion based on whether there is any selection
+    useEffect(() => {
+        if (!treeInitialized)
+            return;
+        onStepCompletedRef.current(selectedItemIds.size > 0);
+    }, [selectedItemIds.size, treeInitialized]);
+    const buildTreeNodes = useCallback((items) => {
+        // Fallback: Build simple tree from items for non-subitem discovery
+        const itemMap = new Map();
+        const childrenMap = new Map();
+        items.forEach(item => {
+            itemMap.set(item.id, item);
+            if (item.parentId) {
+                if (!childrenMap.has(item.parentId))
+                    childrenMap.set(item.parentId, []);
+                childrenMap.get(item.parentId).push(item);
+            }
+        });
+        const buildNode = (item) => ({
+            key: item.id,
+            label: item.name || item.id,
+            data: { id: item.id, name: item.name, path: item.path, hasChildren: item.hasChildren },
+            children: (childrenMap.get(item.id) || []).map(buildNode)
+        });
+        const originalItemIds = new Set(data.items.map(item => item.descriptor.id));
+        const rootItems = items.filter(item => !item.parentId || !itemMap.has(item.parentId) || originalItemIds.has(item.id));
+        return rootItems.map(buildNode);
+    }, [data.items]);
+    // PerfectTree integrations
+    const expandedKeys = useMemo(() => Array.from(expandedIds), [expandedIds]);
+    const selectedKeys = useMemo(() => Array.from(selectedItemIds), [selectedItemIds]);
+    const getDescendantIds = (nodeKey) => {
+        const findNode = (nodes) => {
+            for (const node of nodes) {
+                if (node.key === nodeKey)
+                    return node;
+                if (node.children) {
+                    const found = findNode(node.children);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        const node = findNode(treeNodes);
+        if (!node?.children)
+            return [];
+        const descendants = [];
+        const traverse = (children) => {
+            children.forEach(child => {
+                descendants.push(child.key);
+                if (child.children)
+                    traverse(child.children);
+            });
+        };
+        traverse(node.children);
+        return descendants;
+    };
+    const getDescendantPageIds = (nodeKey) => {
+        const findNode = (nodes) => {
+            for (const node of nodes) {
+                if (node.key === nodeKey)
+                    return node;
+                if (node.children) {
+                    const found = findNode(node.children);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        const root = findNode(treeNodes);
+        if (!root?.children)
+            return [];
+        const out = [];
+        const walk = (children) => {
+            children.forEach(child => {
+                const isPage = child?.data?.hasLayout === true;
+                if (isPage)
+                    out.push(child.key);
+                if (child.children)
+                    walk(child.children);
+            });
+        };
+        walk(root.children);
+        return out;
+    };
+    const handleCancel = () => {
+        setCancelled(true);
+        cancelledRef.current = true;
+        setIsDiscovering(false);
+        setDiscoveryComplete(true);
+        // Update allDiscoveredItems with current results
+        setAllDiscoveredItems([...discoveredItemsRef.current]);
+        // Build tree structure with current items
+        const nodes = buildTreeNodes(discoveredItemsRef.current);
+        setTreeNodes(nodes);
+        // Expand all root nodes by default
+        const rootNodeIds = nodes.map(node => node.key);
+        setExpandedIds(new Set(rootNodeIds));
+        // Mark tree as fully initialized
+        setTreeInitialized(true);
+    };
+    // Handle individual checkbox changes (no parent-child cascading)
+    const handleIndividualCheckboxChange = (itemId, checked) => {
+        setUserSelectionOverride(true);
+        const newSelection = new Set(selectedItemIds);
+        if (checked) {
+            newSelection.add(itemId);
+        }
+        else {
+            newSelection.delete(itemId);
+        }
+        setSelectedItemIds(newSelection);
+    };
+    return (_jsxs("div", { className: "flex flex-col gap-4 p-6 h-full", "data-testid": "subitem-discovery-step", children: [_jsxs("div", { className: "mb-2", children: [_jsx("h3", { className: "text-lg font-medium mb-1", children: "Discover Subitems" }), _jsx("p", { className: "text-sm text-gray-600", children: "Scanning for subitems to include in translation..." })] }), _jsxs("div", { className: "border rounded p-4 bg-gray-50 min-h-[120px]", "data-testid": "discovery-status-container", children: [_jsxs("div", { className: "flex items-center justify-between mb-4", children: [_jsxs("div", { className: "flex items-center gap-2", children: [isDiscovering && _jsx(Spinner, { "data-testid": "discovery-spinner" }), _jsx("span", { className: "font-medium", "data-testid": "discovery-status-text", children: isDiscovering ? 'Discovering subitems...' :
+                                            discoveryComplete ? 'Discovery Complete' :
+                                                'Ready to discover' })] }), isDiscovering && (_jsx(Button, { size: "sm", onClick: handleCancel, "data-testid": "discovery-cancel-button", children: "Cancel" }))] }), _jsx("div", { className: "text-sm text-gray-600 mb-3", "data-testid": "discovery-summary", children: discoveredCount > 0 ? (_jsxs("p", { "data-testid": "discovery-total-count", children: [_jsxs("span", { className: "font-medium text-blue-600", children: [discoveredCount, " total items found"] }), _jsx("br", {}), _jsxs("span", { className: "text-xs", children: ["Original items: ", data.items.length, " | Subitems discovered: ", Math.max(0, discoveredCount - data.items.length)] }), isDiscovering && (_jsxs(_Fragment, { children: [_jsx("br", {}), _jsx("span", { className: "text-xs text-gray-500 italic", children: "Item tree will appear when discovery completes" })] }))] })) : (_jsx("p", { children: "No items discovered yet." })) }), !isDiscovering && !discoveryComplete && (_jsx(Button, { size: "sm", onClick: startDiscovery, "data-testid": "discovery-start-button", children: "Start Discovery" })), _jsx("div", { className: "mt-4 min-h-[400px]", children: !isDiscovering && discoveryComplete && treeInitialized && allDiscoveredItems.length > 0 && treeNodes.length > 0 ? (_jsx("div", { children: _jsxs("div", { className: "border-t pt-4", "data-testid": "item-selection-section", children: [_jsxs("div", { className: "flex items-center justify-between mb-3", children: [_jsx("h3", { className: "text-lg font-medium", children: "Select Items to Translate" }), _jsxs("div", { className: "flex items-center gap-4", children: [_jsx("span", { className: "text-sm text-gray-600", "data-testid": "selection-summary-header", children: selectedItemIds.size > 0 ? `${selectedItemIds.size} selected` : "No items selected" }), _jsx(Button, { size: "sm", variant: "outline", onClick: () => { setUserSelectionOverride(true); setSelectedItemIds(new Set(allDiscoveredItems.map(i => i.id))); }, "data-testid": "select-all-items-button", children: "Select All" }), _jsx(Button, { size: "sm", variant: "outline", onClick: () => { setUserSelectionOverride(true); setSelectedItemIds(new Set()); }, "data-testid": "select-none-items-button", children: "Select None" })] })] }), _jsx("div", { className: "text-sm text-gray-600 mb-3", "data-testid": "selection-summary", children: _jsx("span", { className: "text-gray-500", children: "Tip: Hold Shift and click a checkbox to toggle all descendants." }) }), treeNodes.length > 0 && (_jsx("div", { className: "border rounded-lg h-80 overflow-auto", "data-testid": "item-tree-view", children: _jsx(PerfectTree, { nodes: treeNodes, expandedKeys: expandedKeys, selectedKeys: selectedKeys, onToggleExpand: (key) => {
+                                                setExpandedIds(prev => {
+                                                    const next = new Set(prev);
+                                                    if (next.has(key))
+                                                        next.delete(key);
+                                                    else
+                                                        next.add(key);
+                                                    return next;
+                                                });
+                                            }, onSelect: (key, event) => {
+                                                setUserSelectionOverride(true);
+                                                const targetNode = key;
+                                                const shift = event?.shiftKey === true;
+                                                const next = new Set(selectedItemIds);
+                                                // Only select pages
+                                                const findNode = (nodes) => {
+                                                    for (const n of nodes) {
+                                                        if (n.key === targetNode)
+                                                            return n;
+                                                        if (n.children) {
+                                                            const f = findNode(n.children);
+                                                            if (f)
+                                                                return f;
+                                                        }
+                                                    }
+                                                    return null;
+                                                };
+                                                const n = findNode(treeNodes);
+                                                const isPage = n?.data?.hasLayout === true;
+                                                if (isPage) {
+                                                    const ids = shift ? [key, ...getDescendantIds(key)] : [key];
+                                                    if (!next.has(key))
+                                                        ids.forEach(id => next.add(id));
+                                                    else
+                                                        ids.forEach(id => next.delete(id));
+                                                }
+                                                else {
+                                                    // Folder row click toggles all descendant pages
+                                                    const pageIds = getDescendantPageIds(key);
+                                                    const allSelected = pageIds.length > 0 && pageIds.every(id => next.has(id));
+                                                    if (allSelected)
+                                                        pageIds.forEach(id => next.delete(id));
+                                                    else
+                                                        pageIds.forEach(id => next.add(id));
+                                                }
+                                                setSelectedItemIds(next);
+                                            }, renderNode: (node) => {
+                                                const isPage = node?.data?.hasLayout === true;
+                                                const pageIds = !isPage ? getDescendantPageIds(node.key) : [];
+                                                const allSelected = !isPage ? (pageIds.length > 0 && pageIds.every(id => selectedItemIds.has(id))) : false;
+                                                const someSelected = !isPage ? (pageIds.some(id => selectedItemIds.has(id)) && !allSelected) : false;
+                                                const isChecked = isPage ? selectedItemIds.has(node.key) : allSelected;
+                                                const icon = node?.data?.icon;
+                                                return (_jsxs("div", { className: "flex items-center gap-2", children: [icon && (_jsx("img", { src: icon, alt: "", className: "w-4 h-4" })), _jsx("input", { type: "checkbox", checked: isChecked, ref: (el) => { if (el)
+                                                                el.indeterminate = someSelected; }, onMouseDown: (e) => { shiftToggleRef.current = e.shiftKey; }, onChange: (e) => {
+                                                                setUserSelectionOverride(true);
+                                                                const next = new Set(selectedItemIds);
+                                                                if (isPage) {
+                                                                    const withDesc = shiftToggleRef.current && (node.children?.length ?? 0) > 0;
+                                                                    const ids = withDesc ? [node.key, ...getDescendantIds(node.key)] : [node.key];
+                                                                    if (e.currentTarget.checked)
+                                                                        ids.forEach(id => next.add(id));
+                                                                    else
+                                                                        ids.forEach(id => next.delete(id));
+                                                                }
+                                                                else {
+                                                                    const ids = getDescendantPageIds(node.key);
+                                                                    const allSel = ids.length > 0 && ids.every(id => next.has(id));
+                                                                    if (e.currentTarget.checked && !allSel)
+                                                                        ids.forEach(id => next.add(id));
+                                                                    else if (!e.currentTarget.checked && allSel)
+                                                                        ids.forEach(id => next.delete(id));
+                                                                    else {
+                                                                        // Toggle based on current
+                                                                        if (allSel)
+                                                                            ids.forEach(id => next.delete(id));
+                                                                        else
+                                                                            ids.forEach(id => next.add(id));
+                                                                    }
+                                                                }
+                                                                setSelectedItemIds(next);
+                                                                shiftToggleRef.current = false;
+                                                            } }), _jsx("span", { children: node.label })] }));
+                                            } }) }))] }) })) : isDiscovering ? (
+                        // Loading skeleton for discovery results
+                        _jsxs("div", { children: [_jsx("div", { className: "p-3 bg-blue-50 border border-blue-200 rounded mb-4", children: _jsx("div", { className: "h-4 bg-blue-200 rounded w-64 animate-pulse" }) }), _jsxs("div", { className: "border-t pt-4", children: [_jsxs("div", { className: "flex items-center justify-between mb-3", children: [_jsx("div", { className: "h-6 bg-gray-200 rounded w-48 animate-pulse" }), _jsxs("div", { className: "flex gap-2", children: [_jsx("div", { className: "h-8 bg-gray-200 rounded w-20 animate-pulse" }), _jsx("div", { className: "h-8 bg-gray-200 rounded w-20 animate-pulse" })] })] }), _jsx("div", { className: "h-4 bg-gray-200 rounded w-64 mb-3 animate-pulse" }), _jsx("div", { className: "border rounded-lg h-80 overflow-auto", children: _jsx("div", { className: "p-3 space-y-2", children: [...Array(8)].map((_, i) => (_jsxs("div", { className: "flex items-center gap-3 animate-pulse", children: [_jsx("div", { className: "h-4 w-4 bg-gray-200 rounded" }), _jsx("div", { className: "h-4 bg-gray-200 rounded w-48" })] }, i))) }) })] })] })) : (
+                        // Empty state
+                        _jsx("div", { className: "flex items-center justify-center h-80 border rounded-lg bg-gray-50", children: _jsxs("div", { className: "text-center text-gray-500", children: [_jsx("p", { children: "Ready to discover subitems" }), _jsx("p", { className: "text-sm", children: "Discovery will start automatically" })] }) })) })] })] }));
+}

package/dist/localization/src/steps/index.d.ts

@@ -0,0 +1,5 @@
+export { ServiceLanguageSelectionStep } from "./ServiceLanguageSelectionStep";
+export { SubitemDiscoveryStep } from "./SubitemDiscoveryStep";
+export { MetadataInputStep } from "./MetadataInputStep";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/localization/src/steps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/steps/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,cAAc,SAAS,CAAC"}

package/dist/localization/src/steps/index.js

@@ -0,0 +1,4 @@
+export { ServiceLanguageSelectionStep } from "./ServiceLanguageSelectionStep";
+export { SubitemDiscoveryStep } from "./SubitemDiscoveryStep";
+export { MetadataInputStep } from "./MetadataInputStep";
+export * from "./types";

package/dist/localization/src/steps/types.d.ts

@@ -0,0 +1,68 @@
+import { FullItem, ItemDescriptor, EditContextType } from "@parhelia/core";
+export type TranslationProviderInfo = {
+    name: string;
+    displayName: string;
+    supportedLanguages: string[];
+};
+export type TranslationStatus = {
+    targetLanguage: string;
+    sourceLanguage?: string;
+    status: string;
+    timestamp: string;
+    hash?: string;
+    message?: string;
+    batchId?: string;
+};
+export type LanguageData = {
+    name: string;
+    languageCode: string;
+    items: ItemDescriptor[];
+    translationStatus?: TranslationStatus;
+};
+export type TranslationDialogResult = {
+    translationProvider: string;
+    targetLanguages: string[];
+    includeSubitems: boolean;
+    discoveredItems: FullItem[];
+    metadata?: any;
+    batchId?: string;
+};
+export type TranslationWizardConfiguration = {
+    skipLanguageSelection?: boolean;
+    predefinedTargetLanguages?: string[];
+    predefinedProvider?: string;
+    predefinedMetadata?: any;
+};
+export type TranslationWizardData = {
+    items: FullItem[];
+    targetLanguages: string[];
+    translationProvider: string;
+    includeSubitems: boolean;
+    discoveredItems: FullItem[];
+    languageData: Map<string, LanguageData>;
+    translationProviders: TranslationProviderInfo[];
+    itemMetadata: Map<string, Map<string, string>>;
+    metadata?: any;
+    [key: string]: any;
+};
+export type TranslationStepProps = {
+    data: TranslationWizardData;
+    setData: (data: TranslationWizardData) => void;
+    editContext: EditContextType;
+    onStepCompleted: (completed: boolean) => void;
+    setBeforeNextCallback?: (callback: (() => Promise<boolean>) | null) => void;
+    setFooterActions?: (actions: {
+        key: string;
+        label: string;
+        disabled?: boolean;
+        onClick: () => void;
+        signature?: string;
+    }[]) => void;
+    requestClose?: (result: TranslationDialogResult | null) => void;
+};
+export type LocalizeItemDialogProps = {
+    items: FullItem[];
+    editContext: EditContextType;
+    configuration?: TranslationWizardConfiguration;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/localization/src/steps/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/steps/types.ts"],"names":[],"mappings":"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"}

package/dist/localization/src/steps/types.js

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

package/dist/localization/src/translation-center/BatchTranslationView.d.ts

@@ -0,0 +1,7 @@
+interface BatchTranslationViewProps {
+    batchId: string;
+    onBack?: () => void;
+}
+export declare function BatchTranslationView({ batchId, onBack }: BatchTranslationViewProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=BatchTranslationView.d.ts.map

package/dist/localization/src/translation-center/BatchTranslationView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchTranslationView.d.ts","sourceRoot":"","sources":["../../../../src/translation-center/BatchTranslationView.tsx"],"names":[],"mappings":"AAiBA,UAAU,yBAAyB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAoCD,wBAAgB,oBAAoB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,yBAAyB,2CAuxBlF"}