@parhelia/localization 0.1.11455 → 0.1.11458

package/dist/dist/LocalizeItemCommand.d.ts

@@ -0,0 +1,8 @@
+import { Command, CommandContext, CommandData, FullItem } from "@parhelia/core";
+export type LocalizeItemCommandData = CommandData & {
+    items: FullItem[];
+};
+export type LocalizeItemCommandContext = CommandContext<LocalizeItemCommandData>;
+export type LocalizeItemCommand = Command<LocalizeItemCommandData>;
+export declare const localizeItemCommand: LocalizeItemCommand;
+//# sourceMappingURL=LocalizeItemCommand.d.ts.map

package/dist/dist/LocalizeItemCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalizeItemCommand.d.ts","sourceRoot":"","sources":["../src/LocalizeItemCommand.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAUhF,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG;IAClD,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,cAAc,CAAC,uBAAuB,CAAC,CAAC;AACjF,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;AAEnE,eAAO,MAAM,mBAAmB,EAAE,mBAgDjC,CAAC"}

package/dist/dist/LocalizeItemCommand.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { Globe as LucideGlobe } from "lucide-react";
+import { LocalizeItemDialog } from "./LocalizeItemDialog";
+// Icon wrapper to avoid React 19 JSX type issues with forwardRef components.
+// Use React.createElement so we don't call the forwardRef objects as functions.
+const GlobeIcon = (props) => React.createElement(LucideGlobe, props);
+export const localizeItemCommand = {
+    id: "localizeItem",
+    label: "Localize",
+    icon: _jsx(GlobeIcon, { strokeWidth: 1 }),
+    disabled: (context) => {
+        if (!context.data?.items || context.data.items.length === 0) {
+            return true;
+        }
+        // Check if multi-item is disabled and multiple items are selected
+        const multiItemEnabled = context.editContext?.configuration?.localization?.multiItem !== false;
+        if (!multiItemEnabled && context.data.items.length > 1) {
+            return true; // Disable command when multiple items selected in single-item mode
+        }
+        return false;
+    },
+    execute: async (context) => {
+        const items = context.data?.items;
+        if (!items || !items?.length) {
+            return;
+        }
+        const result = await context.openDialog(LocalizeItemDialog, {
+            items: items,
+            editContext: context.editContext,
+        });
+        // If translation was started (result contains batchId), navigate to the batch view
+        if (result?.batchId) {
+            const translationManagementEnabled = context.editContext?.configuration?.localization?.translationManagement !== false;
+            if (translationManagementEnabled) {
+                // Synchronous URL update to avoid race with view URL sync
+                const params = new URLSearchParams(window.location.search);
+                params.set("view", "translation-management");
+                params.set("batchId", result.batchId);
+                const newUrl = `${window.location.pathname}?${params.toString()}`;
+                window.history.pushState(null, "", newUrl);
+                // Now switch the view; URL already contains batchId
+                context.editContext.switchView("translation-management");
+            }
+        }
+        return result;
+    },
+};

package/dist/dist/LocalizeItemDialog.d.ts

@@ -0,0 +1,4 @@
+import { DialogProps } from "@parhelia/core";
+import { TranslationDialogResult, LocalizeItemDialogProps } from "./steps/types";
+export declare function LocalizeItemDialog(props: LocalizeItemDialogProps & DialogProps<TranslationDialogResult>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LocalizeItemDialog.d.ts.map

package/dist/dist/LocalizeItemDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalizeItemDialog.d.ts","sourceRoot":"","sources":["../src/LocalizeItemDialog.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAI7C,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,eAAe,CAAC;AAgBvB,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,uBAAuB,GAAG,WAAW,CAAC,uBAAuB,CAAC,2CA8PtE"}

package/dist/dist/LocalizeItemDialog.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, Button, cn, } from "@parhelia/core";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ChevronRight as LucideChevronRight } from "lucide-react";
+import { useTranslationWizard } from "./hooks/useTranslationWizard";
+import { performDefaultTranslation, generateBatchId } from "./LocalizeItemUtils";
+// Wrapper so React 19 sees a plain function component instead of a forwardRef exotic component
+const ChevronRightIcon = (props) => LucideChevronRight(props);
+// Note: DialogButtons is an internal component that might need to be added to core exports
+// For now, we'll implement it inline
+const DialogButtons = ({ children, ...props }) => (_jsx("div", { className: "flex justify-end gap-2 pt-4 border-t mt-auto px-6 pb-6", ...props, children: children }));
+export function LocalizeItemDialog(props) {
+    const editContext = props.editContext;
+    const configuration = editContext.configuration.translationWizard;
+    const [currentStepIndex, setCurrentStepIndex] = useState(0);
+    const [completedByStepId, setCompletedByStepId] = useState({});
+    const [beforeNextCallback, setBeforeNextCallback] = useState(null);
+    const { wizardData, setWizardData } = useTranslationWizard(props);
+    // Keep a ref to the latest wizard data to avoid stale closure issues
+    const latestWizardDataRef = useRef(wizardData);
+    latestWizardDataRef.current = wizardData;
+    // Clear footer actions when step changes to avoid stale actions from previous steps
+    const [footerActions, setFooterActions] = useState([]);
+    useEffect(() => {
+        setFooterActions([]);
+    }, [currentStepIndex]);
+    // Provide stable callbacks to steps to avoid update loops
+    const lastActionsSigRef = useRef("");
+    const provideFooterActions = useCallback((actions) => {
+        const normalized = (actions || []).map(a => ({ key: a.key, label: a.label, disabled: !!a.disabled, signature: a.signature || "" }));
+        const signature = JSON.stringify(normalized);
+        if (signature === lastActionsSigRef.current)
+            return;
+        lastActionsSigRef.current = signature;
+        setFooterActions(actions || []);
+    }, []);
+    const requestCloseCb = useCallback((result) => {
+        props.onClose?.(result);
+    }, [props.onClose]);
+    // Filter steps based on skip conditions
+    const activeSteps = configuration.steps.filter((step) => !step.skipCondition || !step.skipCondition(wizardData));
+    const currentStep = activeSteps[currentStepIndex];
+    const isLastStep = currentStepIndex === activeSteps.length - 1;
+    const canProceed = !!(currentStep && completedByStepId[currentStep.id]);
+    const handleNext = async () => {
+        if (beforeNextCallback && typeof beforeNextCallback === 'function') {
+            const canProceed = await beforeNextCallback();
+            if (!canProceed)
+                return;
+        }
+        if (currentStep?.beforeNext) {
+            const canProceed = await currentStep.beforeNext(wizardData, editContext);
+            if (!canProceed)
+                return;
+        }
+        if (isLastStep) {
+            await handleFinish();
+        }
+        else {
+            setCurrentStepIndex(currentStepIndex + 1);
+        }
+    };
+    const handlePrevious = () => {
+        if (currentStepIndex > 0) {
+            // Clear the callback when moving to previous step
+            setBeforeNextCallback(null);
+            setCurrentStepIndex(currentStepIndex - 1);
+        }
+    };
+    const handleFinish = useCallback(async () => {
+        try {
+            // Use the ref to get the absolute latest wizard data
+            const currentWizardData = latestWizardDataRef.current;
+            const result = {
+                translationProvider: currentWizardData.translationProvider,
+                targetLanguages: currentWizardData.targetLanguages,
+                includeSubitems: currentWizardData.includeSubitems,
+                discoveredItems: currentWizardData.discoveredItems,
+            };
+            if (currentWizardData.translationProvider === "Create Versions") {
+                props.onClose?.(result);
+            }
+            else {
+                try {
+                    const batchId = generateBatchId();
+                    const translationResult = await performDefaultTranslation(currentWizardData, editContext, batchId);
+                    console.log("Translation completed successfully:", translationResult);
+                    // Include batchId in result for navigation to translation management
+                    const resultWithBatch = { ...result, batchId };
+                    // Close dialog and let parent component handle navigation to translation management
+                    props.onClose?.(resultWithBatch);
+                }
+                catch (error) {
+                    console.error("Translation failed:", error);
+                    // Still close the dialog even on error
+                    props.onClose?.(result);
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error in handleFinish:", error);
+            props.onClose?.(null);
+        }
+    }, [editContext, props]);
+    const handleStepCompleted = useCallback((completed) => {
+        if (!currentStep)
+            return;
+        setCompletedByStepId(prev => ({ ...prev, [currentStep.id]: completed }));
+    }, [currentStep?.id]);
+    const StepComponent = currentStep?.component;
+    return (_jsx(Dialog, { open: true, onOpenChange: (open) => {
+            // Only close when explicitly requested (e.g., close button clicked)
+            if (!open) {
+                props.onClose?.(null);
+            }
+        }, children: _jsxs(DialogContent, { className: "w-[90vw] max-w-5xl h-[85vh] max-h-[900px] min-h-[700px] overflow-hidden flex flex-col", "data-testid": "translation-wizard-dialog", onPointerDownOutside: (e) => e.preventDefault(), onEscapeKeyDown: (e) => e.preventDefault(), "aria-describedby": "translation-wizard-description", style: {
+                width: 'min(90vw, 1280px)',
+                height: 'min(85vh, 900px)',
+                minHeight: '700px'
+            }, children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { "data-testid": "translation-wizard-title", children: "Translation Wizard" }), _jsx("div", { id: "translation-wizard-description", className: "sr-only", children: currentStep?.description || "Configure and start translation for your content." })] }), _jsxs("div", { className: "flex flex-1 flex-col min-h-0", children: [_jsx("div", { className: "border-b border-gray-300 bg-white px-4", "data-testid": "translation-wizard-step-navigation", children: _jsx("div", { className: "flex items-center gap-3 py-2", children: activeSteps.map((step, index) => (_jsxs("div", { className: "flex items-center gap-2", "data-testid": `step-indicator-${step.id}`, children: [_jsx("div", { className: cn("flex h-8 w-8 items-center justify-center rounded-full border text-sm font-medium", currentStepIndex === index &&
+                                                "border-blue-500 text-blue-500 bg-blue-50", currentStepIndex < index && "border-gray-300 text-gray-400", currentStepIndex > index &&
+                                                "bg-blue-500 text-white border-blue-500"), "data-testid": `step-indicator-circle-${step.id}`, children: currentStepIndex > index ? "✓" : index + 1 }), _jsx("span", { className: cn("text-sm", currentStepIndex === index
+                                                ? "text-blue-600 font-medium"
+                                                : currentStepIndex > index
+                                                    ? "text-blue-600"
+                                                    : "text-gray-400"), "data-testid": `step-indicator-label-${step.id}`, children: step.name }), index < activeSteps.length - 1 && (_jsx(ChevronRightIcon, { className: "w-4 h-4 text-gray-400 mx-2" }))] }, step.id))) }) }), _jsx("div", { className: "flex-1 overflow-y-auto min-h-0", "data-testid": "translation-wizard-step-content", children: StepComponent && (_jsx("div", { className: "h-full", children: _jsx(StepComponent, { data: wizardData, setData: setWizardData, editContext: editContext, onStepCompleted: handleStepCompleted, setBeforeNextCallback: (cb) => {
+                                        setBeforeNextCallback(() => cb);
+                                    }, setFooterActions: provideFooterActions, requestClose: requestCloseCb }) })) }), _jsxs(DialogButtons, { "data-testid": "translation-wizard-dialog-buttons", children: [_jsx(Button, { onClick: () => props.onClose?.(null), variant: "outline", size: "default", "data-testid": "translation-wizard-cancel-button", children: "Cancel" }), currentStepIndex > 0 && (_jsx(Button, { onClick: handlePrevious, variant: "outline", size: "default", "data-testid": "translation-wizard-previous-button", children: "Previous" })), footerActions.map((a) => (_jsx(Button, { onClick: a.onClick, disabled: !!a.disabled, variant: "default", size: "default", "data-testid": `translation-wizard-footer-action-${a.key}`, children: a.label }, a.key))), _jsx(Button, { onClick: handleNext, disabled: !canProceed, variant: "default", size: "default", "data-testid": "translation-wizard-next-button", children: isLastStep ? "Start Translation" : "Next" })] })] })] }) }));
+}

package/dist/dist/LocalizeItemUtils.d.ts

@@ -0,0 +1,17 @@
+import { TranslationStatus } from "./types";
+import { FullItem } from "@parhelia/core";
+import { TranslationWizardData } from "./steps/types";
+import { EditContextType } from "@parhelia/core";
+export declare function generateBatchId(): string;
+export type StartedTranslation = {
+    itemId: string;
+    targetLanguage: string;
+    jobId?: string;
+};
+export type TranslationResult = {
+    started: StartedTranslation[];
+    batchId?: string;
+};
+export declare function performDefaultTranslation(wizardData: TranslationWizardData, editContext: EditContextType, predefinedBatchId?: string): Promise<TranslationResult>;
+export declare const defaultTranslateAll: (languageCodes: string[], translationStatus: TranslationStatus[], sessionId: string, item: FullItem, translationProvider: string) => Promise<TranslationResult>;
+//# sourceMappingURL=LocalizeItemUtils.d.ts.map

package/dist/dist/LocalizeItemUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalizeItemUtils.d.ts","sourceRoot":"","sources":["../src/LocalizeItemUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIjD,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAIF,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,qBAAqB,EACjC,WAAW,EAAE,eAAe,EAC5B,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,iBAAiB,CAAC,CAqE5B;AAGD,eAAO,MAAM,mBAAmB,GAAU,eAAe,MAAM,EAAE,EAAE,mBAAmB,iBAAiB,EAAE,EAAE,WAAW,MAAM,EAAE,MAAM,QAAQ,EAAE,qBAAqB,MAAM,+BA0BxK,CAAC"}

package/dist/dist/LocalizeItemUtils.js

@@ -0,0 +1,93 @@
+import { requestBatchTranslation } from "./services/translationService";
+// Shared utility for generating unique batch IDs
+export function generateBatchId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}-${performance.now().toString(36).substring(2, 8)}`;
+}
+// Unified translation function that handles both single and batch translations
+// Now always uses batch logic for traceability in recentTranslation view
+export async function performDefaultTranslation(wizardData, editContext, predefinedBatchId) {
+    const batchId = predefinedBatchId || generateBatchId();
+    const itemsToTranslate = wizardData.includeSubitems
+        ? wizardData.discoveredItems
+        : wizardData.items;
+    // Prepare all translation requests
+    const translationRequests = [];
+    for (const item of itemsToTranslate) {
+        for (const language of wizardData.targetLanguages) {
+            const languageInfo = wizardData.languageData.get(language);
+            if (!languageInfo?.translationStatus)
+                continue;
+            const status = languageInfo.translationStatus;
+            if (status.sourceLanguage === language)
+                continue;
+            const translationItem = {
+                itemId: item.descriptor.id,
+                targetLanguage: language,
+                sourceLanguage: status.sourceLanguage || "en",
+            };
+            // Get metadata for this specific item and language
+            const itemLanguageMetadata = wizardData.itemMetadata.get(item.descriptor.id)?.get(language);
+            if (itemLanguageMetadata) {
+                translationItem.metadata = itemLanguageMetadata;
+            }
+            translationRequests.push(translationItem);
+        }
+    }
+    try {
+        const batchResult = await requestBatchTranslation({
+            sessionId: editContext.sessionId,
+            batchId,
+            provider: wizardData.translationProvider,
+            batchMetadata: wizardData.metadata,
+            translations: translationRequests,
+        });
+        if (batchResult.type === "error") {
+            console.error('Translation request failed:', batchResult);
+            return { started: [], batchId };
+        }
+        const batchResponse = batchResult.data;
+        if (!batchResponse) {
+            console.error('Batch response is undefined');
+            return { started: [], batchId };
+        }
+        const started = batchResponse.started?.map((result) => ({
+            itemId: result.itemId,
+            targetLanguage: result.targetLanguage,
+            jobId: result.jobId,
+        })) || [];
+        if (batchResponse.skipped && batchResponse.skipped.length > 0) {
+            console.warn('Some translations were skipped:', batchResponse.skipped);
+        }
+        return { started, batchId };
+    }
+    catch (error) {
+        console.error('Translation request failed:', error);
+        return { started: [], batchId };
+    }
+}
+// Legacy function for backward compatibility
+export const defaultTranslateAll = async (languageCodes, translationStatus, sessionId, item, translationProvider) => {
+    // Create a minimal wizardData-like object for the legacy function
+    const wizardData = {
+        items: [item],
+        targetLanguages: languageCodes,
+        languageData: new Map(languageCodes.map(lang => {
+            const status = translationStatus?.find(x => x.targetLanguage === lang);
+            return [lang, {
+                    name: lang,
+                    languageCode: lang,
+                    items: [item.descriptor],
+                    translationStatus: status
+                }];
+        })),
+        translationProvider,
+        includeSubitems: false,
+        discoveredItems: [],
+        itemMetadata: new Map(),
+        metadata: null,
+        translationProviders: []
+    };
+    const editContext = { sessionId };
+    const result = await performDefaultTranslation(wizardData, editContext);
+    return result;
+};

package/dist/dist/api/discovery.d.ts

@@ -0,0 +1,36 @@
+export type DiscoveredItem = {
+    id: string;
+    name: string;
+    path: string;
+    parentId?: string | null;
+    hasChildren: boolean;
+    hasLayout?: boolean;
+};
+export type TreeNode = {
+    key: string;
+    label: string;
+    data: DiscoveredItem;
+    children?: TreeNode[];
+};
+export type BackendTreeNode = {
+    id: string;
+    name: string;
+    path: string;
+    hasLayout: boolean;
+    isFolder: boolean;
+    icon?: string;
+    children: BackendTreeNode[];
+};
+export type DiscoverItemsTreeRequest = {
+    rootItemIds: string[];
+    language?: string;
+};
+export type DiscoverItemsTreeResponse = {
+    trees: BackendTreeNode[];
+    totalIncluded: number;
+    isComplete: boolean;
+};
+export declare function discoverItemsTree(req: DiscoverItemsTreeRequest, sessionId?: string): Promise<DiscoverItemsTreeResponse>;
+export declare function convertBackendTreeToTreeNodes(trees: BackendTreeNode[]): TreeNode[];
+export declare function flattenPagesFromBackendTrees(trees: BackendTreeNode[]): DiscoveredItem[];
+//# sourceMappingURL=discovery.d.ts.map

package/dist/dist/api/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/api/discovery.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC;AAInG,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,wBAAwB,EAC7B,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,yBAAyB,CAAC,CAWpC;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,QAAQ,EAAE,CAQlF;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,cAAc,EAAE,CAQvF"}

package/dist/dist/api/discovery.js

@@ -0,0 +1,29 @@
+import { post } from "@parhelia/core";
+export async function discoverItemsTree(req, sessionId) {
+    const { data, type, details } = await post("/parhelia/translation/discoveritemstree", {
+        RootItemIds: req.rootItemIds,
+        Language: req.language,
+    }, sessionId);
+    if (type !== "success" || !data)
+        throw new Error(details || "Failed to discover items tree");
+    return data;
+}
+export function convertBackendTreeToTreeNodes(trees) {
+    const convert = (n) => ({
+        key: n.id,
+        label: n.name,
+        data: { id: n.id, name: n.name, path: n.path, hasLayout: n.hasLayout, icon: n.icon, parentId: undefined, hasChildren: (n.children?.length ?? 0) > 0 },
+        children: n.children?.map(convert) || [],
+    });
+    return trees.map(convert);
+}
+export function flattenPagesFromBackendTrees(trees) {
+    const out = [];
+    const walk = (n) => {
+        if (n.hasLayout)
+            out.push({ id: n.id, name: n.name, path: n.path, hasChildren: (n.children?.length ?? 0) > 0, parentId: undefined });
+        n.children?.forEach(walk);
+    };
+    trees.forEach(walk);
+    return out;
+}

package/dist/dist/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const DISCOVERY_CONFIRMATION_THRESHOLD = 100;
+export declare const EXCLUDED_TEMPLATE_IDS: string[];
+export declare const DIALOG_DIMENSIONS: {
+    width: string;
+    height: string;
+};
+export declare const STEP_STATES: {
+    readonly COMPLETED: "completed";
+    readonly CURRENT: "current";
+    readonly PENDING: "pending";
+};
+export declare const STORAGE_KEYS: {
+    readonly TRANSLATION_PROVIDER: "editor.translationProvider";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gCAAgC,MAAM,CAAC;AAGpD,eAAO,MAAM,qBAAqB,UAEjC,CAAC;AAGF,eAAO,MAAM,iBAAiB;;;CAG7B,CAAC;AAGF,eAAO,MAAM,WAAW;;;;CAId,CAAC;AAGX,eAAO,MAAM,YAAY;;CAEf,CAAC"}

package/dist/dist/constants.js

@@ -0,0 +1,21 @@
+// Discovery configuration
+export const DISCOVERY_CONFIRMATION_THRESHOLD = 100; // Pause every N subitems
+// Template IDs to exclude from translation
+export const EXCLUDED_TEMPLATE_IDS = [
+    "de8bfdac-5f9f-40c3-a680-2fce9997ae28" // System template ID
+];
+// Dialog dimensions
+export const DIALOG_DIMENSIONS = {
+    width: "75vw",
+    height: "75vh"
+};
+// Step progress indicators
+export const STEP_STATES = {
+    COMPLETED: "completed",
+    CURRENT: "current",
+    PENDING: "pending"
+};
+// Local storage keys
+export const STORAGE_KEYS = {
+    TRANSLATION_PROVIDER: "editor.translationProvider"
+};

package/dist/dist/hooks/useTranslationWizard.d.ts

@@ -0,0 +1,6 @@
+import { TranslationWizardData, LocalizeItemDialogProps } from "../steps/types";
+export declare function useTranslationWizard(props: LocalizeItemDialogProps): {
+    wizardData: TranslationWizardData;
+    setWizardData: import("react").Dispatch<import("react").SetStateAction<TranslationWizardData>>;
+};
+//# sourceMappingURL=useTranslationWizard.d.ts.map

package/dist/dist/hooks/useTranslationWizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslationWizard.d.ts","sourceRoot":"","sources":["../../src/hooks/useTranslationWizard.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAMhF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,uBAAuB;;;EA8FlE"}

package/dist/dist/hooks/useTranslationWizard.js

@@ -0,0 +1,78 @@
+import { useState, useEffect } from "react";
+import { getLanguagesAndVersions } from "@parhelia/core";
+import { getTranslationStatus, getTranslationProviders } from "../services/translationService";
+export function useTranslationWizard(props) {
+    const [wizardData, setWizardData] = useState({
+        items: props.items,
+        targetLanguages: [],
+        translationProvider: "",
+        includeSubitems: false,
+        discoveredItems: [],
+        languageData: new Map(),
+        translationProviders: [],
+        itemMetadata: new Map(), // Initialize as Map<string, Map<string, string>>
+        metadata: null, // Initialize with test value
+    });
+    // Load initial data
+    useEffect(() => {
+        const loadInitialData = async () => {
+            const itemDescriptors = props.items.map((x) => x.descriptor);
+            // Load translation providers
+            const providersResult = await getTranslationProviders();
+            const providers = providersResult.data || [];
+            if (providers.length > 0) {
+                const savedProvider = localStorage.getItem("editor.translationProvider");
+                // Validate that saved provider exists in current providers by name
+                const validProvider = savedProvider && providers.find(p => p.name === savedProvider)
+                    ? savedProvider
+                    : providers[0]?.name || "";
+                const defaultProvider = validProvider;
+                // Load languages for each item
+                const itemLanguages = await Promise.all(itemDescriptors.map(async (item) => {
+                    const result = await getLanguagesAndVersions(item);
+                    return result.data?.languages || [];
+                }));
+                // Load translation status for each item
+                const translationStatuses = await Promise.all(itemDescriptors.map(async (item) => {
+                    const result = await getTranslationStatus(item.id);
+                    return result.data || [];
+                }));
+                const languageMap = new Map();
+                itemLanguages.forEach((languages, itemIndex) => {
+                    languages.forEach((language) => {
+                        const languageData = languageMap.get(language.languageCode) || {
+                            name: language.name,
+                            languageCode: language.languageCode,
+                            items: [],
+                        };
+                        if (language.versions > 0 && itemDescriptors[itemIndex]) {
+                            languageData.items.push(itemDescriptors[itemIndex]);
+                        }
+                        const status = translationStatuses[itemIndex]?.find((s) => s.targetLanguage === language.languageCode);
+                        if (status && !languageData.translationStatus) {
+                            languageData.translationStatus = status;
+                        }
+                        languageMap.set(language.languageCode, languageData);
+                    });
+                });
+                setWizardData(prevData => ({
+                    ...prevData,
+                    translationProviders: providers,
+                    translationProvider: defaultProvider,
+                    languageData: languageMap,
+                }));
+            }
+        };
+        loadInitialData();
+    }, [props.items]);
+    // Save translation provider to localStorage when it changes
+    useEffect(() => {
+        if (wizardData.translationProvider) {
+            localStorage.setItem("editor.translationProvider", wizardData.translationProvider);
+        }
+    }, [wizardData.translationProvider]);
+    return {
+        wizardData,
+        setWizardData,
+    };
+}

package/dist/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { ServiceLanguageSelectionStep } from "./steps/ServiceLanguageSelectionStep";
+import { SubitemDiscoveryStep } from "./steps/SubitemDiscoveryStep";
+import { TranslationWizardData } from "./steps/types";
+import { EditorConfiguration } from "@parhelia/core";
+declare const DEFAULT_TRANSLATION_WIZARD_CONFIGURATION: {
+    steps: ({
+        id: string;
+        name: string;
+        description: string;
+        component: typeof ServiceLanguageSelectionStep;
+        skipCondition?: undefined;
+    } | {
+        id: string;
+        name: string;
+        description: string;
+        component: typeof SubitemDiscoveryStep;
+        skipCondition: (data: TranslationWizardData) => boolean;
+    })[];
+};
+declare const SINGLE_ITEM_TRANSLATION_WIZARD_CONFIGURATION: {
+    steps: {
+        id: string;
+        name: string;
+        description: string;
+        component: typeof ServiceLanguageSelectionStep;
+    }[];
+};
+export { DEFAULT_TRANSLATION_WIZARD_CONFIGURATION, SINGLE_ITEM_TRANSLATION_WIZARD_CONFIGURATION };
+export { LocalizeItemDialog } from "./LocalizeItemDialog";
+export { localizeItemCommand } from "./LocalizeItemCommand";
+export { TranslationManagement } from "./translation-center/TranslationManagement";
+export { RecentTranslations } from "./translation-center/RecentTranslations";
+export { BatchTranslationView } from "./translation-center/BatchTranslationView";
+export { LocalizationSetupStep } from "./setup/LocalizationSetupStep";
+export type { LocalizeItemCommand, LocalizeItemCommandContext, LocalizeItemCommandData } from "./LocalizeItemCommand";
+export { defaultTranslateAll, generateBatchId, performDefaultTranslation, type StartedTranslation, type TranslationResult } from "./LocalizeItemUtils";
+export * from "./steps/types";
+export type { TranslationProviderInfo, TranslationStatus } from "./steps/types";
+export type LocalizationConfigOptions = {
+    /**
+     * Enable multi-item translation (allows translating multiple items and their subitems).
+     * When false, restricts translation to single items only.
+     * @default true
+     */
+    multiItem?: boolean;
+    /**
+     * Enable Translation Management view for tracking and managing translation batches.
+     * @default true
+     */
+    translationManagement?: boolean;
+};
+/**
+ * Configures the localization extension for the editor.
+ *
+ * @example
+ * // Full-featured (default): Multi-item translation with subitem discovery
+ * configureLocalization(configuration);
+ * // or explicitly:
+ * configureLocalization(configuration, { multiItem: true });
+ *
+ * @example
+ * // Single-item only: Restricts translation to one item at a time
+ * configureLocalization(configuration, { multiItem: false });
+ *
+ * @param configuration - The editor configuration object
+ * @param options - Optional configuration for localization features
+ */
+export declare function configureLocalization(configuration: EditorConfiguration, options?: LocalizationConfigOptions): EditorConfiguration;
+//# sourceMappingURL=index.d.ts.map

package/dist/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AACpF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAWtD,OAAO,EAAE,mBAAmB,EAAsB,MAAM,gBAAgB,CAAC;AASzE,QAAA,MAAM,wCAAwC;;;;;;;;;;;;8BAalB,qBAAqB;;CAGhD,CAAC;AAEF,QAAA,MAAM,4CAA4C;;;;;;;CAUjD,CAAC;AAEF,OAAO,EAAE,wCAAwC,EAAE,4CAA4C,EAAE,CAAC;AAClG,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,YAAY,EACV,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,yBAAyB,EACzB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhF,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,mBAAmB,EAClC,OAAO,CAAC,EAAE,yBAAyB,uBAmGpC"}