@parhelia/localization 0.1.12789 → 0.1.12790

package/dist/steps/ItemSelectionTree.js

@@ -0,0 +1,326 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { ItemCollectionEditor, } from "@parhelia/core";
+import { streamSubitemCount } from "../api/discovery";
+const SITECORE_ROOT = "11111111-1111-1111-1111-111111111111";
+function fullItemFromDescriptor(descriptor) {
+    return {
+        id: descriptor.id,
+        language: descriptor.language,
+        version: descriptor.version,
+        descriptor: {
+            id: descriptor.id,
+            language: descriptor.language,
+            version: descriptor.version,
+            name: descriptor.name,
+            displayName: descriptor.displayName,
+            path: descriptor.path,
+        },
+        name: descriptor.name ?? "",
+        templateId: descriptor.templateId ?? "",
+        templateName: "",
+        icon: descriptor.icon ?? "",
+        largeIcon: descriptor.icon ?? "",
+        thumbnail: "",
+        path: descriptor.path ?? "",
+        fields: [],
+        canWriteItem: false,
+        canWriteLanguage: false,
+        canWriteWorkflow: false,
+        canRename: false,
+        canDelete: false,
+        canCreate: false,
+        workflowState: "",
+        hasLock: false,
+        hasLayout: true,
+        idPath: descriptor.idPath ?? "",
+        canLock: false,
+        lockedBy: "",
+        isInheritedFromMasterLanguage: false,
+        hasChildren: descriptor.hasChildren ?? false,
+    };
+}
+function fullItemToWithSubtree(item, includeSubitems) {
+    return {
+        descriptor: {
+            id: item.descriptor?.id ?? item.id,
+            language: item.descriptor?.language ?? item.language,
+            version: item.descriptor?.version ?? item.version,
+            name: item.descriptor?.name ?? item.name,
+            displayName: item.descriptor?.displayName ?? item.displayName,
+            path: item.descriptor?.path ?? item.path,
+        },
+        includeSubitems,
+    };
+}
+export function ItemSelectionTree({ data, setData, editContext, isActive = true, onSelectionValidChange, height = 360, }) {
+    const language = useMemo(() => editContext?.item?.language ??
+        editContext?.currentItemDescriptor?.language ??
+        "en", [editContext?.item?.language, editContext?.currentItemDescriptor?.language]);
+    // Seed selection: prefer previously saved tree items, then discoveredItems,
+    // then the wizard's initial `items`. Default includeSubitems = legacy flag.
+    const initialItems = useMemo(() => {
+        if (data.selectionTreeItems && data.selectionTreeItems.length > 0) {
+            return data.selectionTreeItems;
+        }
+        const seed = data.discoveredItems && data.discoveredItems.length > 0
+            ? data.discoveredItems
+            : data.items;
+        return seed.map((item) => fullItemToWithSubtree(item, !!data.includeSubitems));
+        // First mount only — once the user edits, wizard data is downstream.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const [items, setItems] = useState(initialItems);
+    const [selectedInTree, setSelectedInTree] = useState([]);
+    const [selectedFromList, setSelectedFromList] = useState([]);
+    // Async subitem counts keyed by item id. Filtered server-side via
+    // IItemExportFilter (see TranslationController.DiscoverItemsTree). The
+    // running count climbs as chunks arrive; `complete` flips true on the
+    // final chunk so consumers know when to drop the "still counting" hint.
+    const [subitemCounts, setSubitemCounts] = useState(() => data.subitemCounts ?? {});
+    // Mirror local subitemCounts into wizardData so later steps (e.g. the
+    // Start Translation button) can show a live total.
+    const dataRef = useRef(data);
+    dataRef.current = data;
+    useEffect(() => {
+        setData({ ...dataRef.current, subitemCounts });
+    }, [subitemCounts, setData]);
+    // Keep a cache of the richest FullItem we've ever seen for each id so we
+    // can rebuild discoveredItems without re-fetching.
+    const itemCacheRef = useRef(new Map());
+    if (itemCacheRef.current.size === 0) {
+        for (const it of data.items)
+            itemCacheRef.current.set(it.id, it);
+        for (const it of data.discoveredItems || [])
+            itemCacheRef.current.set(it.id, it);
+    }
+    // Build a combined idPath that expands every parent of the current
+    // selection (but not the items themselves). ContentTree's parser
+    // extracts each {guid} segment, so concatenating multiple paths works.
+    const expandIdPath = useMemo(() => {
+        const segments = [];
+        for (const entry of items) {
+            const cached = itemCacheRef.current.get(entry.descriptor.id);
+            const idPath = cached?.idPath;
+            if (!idPath)
+                continue;
+            const parts = idPath.split("/").filter((s) => s.length > 0);
+            // Drop the last segment (the item itself) — we only want parents.
+            parts.pop();
+            for (const part of parts)
+                segments.push(part);
+        }
+        if (segments.length === 0)
+            return undefined;
+        return "/" + segments.join("/");
+    }, [items]);
+    const commitToWizard = useCallback((nextItems) => {
+        const cache = itemCacheRef.current;
+        const discovered = nextItems.map((entry) => cache.get(entry.descriptor.id) ?? fullItemFromDescriptor(entry.descriptor));
+        setData({
+            ...data,
+            selectionTreeItems: nextItems,
+            discoveredItems: discovered,
+            includeSubitems: nextItems.some((i) => i.includeSubitems),
+        });
+    }, [data, setData]);
+    // Commit current state on first mount so wizard data reflects the seed.
+    const didInitialCommitRef = useRef(false);
+    useEffect(() => {
+        if (didInitialCommitRef.current)
+            return;
+        didInitialCommitRef.current = true;
+        commitToWizard(items);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    useEffect(() => {
+        if (isActive)
+            onSelectionValidChange?.(items.length > 0);
+    }, [isActive, onSelectionValidChange, items.length]);
+    // Stream subitem counts in the background for items whose
+    // includeSubitems flag is on. Filtering happens server-side (see
+    // TranslationController.DiscoverSubitemCountStream). The count grows in
+    // real time as the backend walks the subtree. Cached results survive
+    // toggle-off/on; in-flight requests are aborted if the user turns the
+    // flag back off.
+    const sessionId = editContext?.sessionId;
+    const inFlightRef = useRef(new Map());
+    useEffect(() => {
+        const inFlight = inFlightRef.current;
+        const enabledIds = new Set(items.filter((it) => it.includeSubitems).map((it) => it.descriptor.id));
+        // Cancel any streams whose items no longer have the flag on.
+        for (const [id, ctrl] of inFlight) {
+            if (!enabledIds.has(id)) {
+                ctrl.abort();
+                inFlight.delete(id);
+            }
+        }
+        // Start a stream for every newly-enabled item that doesn't already
+        // have a count or an active stream. Cached complete results survive;
+        // a partial (non-complete) object means a previous stream was aborted
+        // mid-flight — restart it.
+        const toStart = items
+            .filter((it) => it.includeSubitems)
+            .map((it) => it.descriptor)
+            .filter((d) => {
+            if (inFlight.has(d.id))
+                return false;
+            const c = subitemCounts[d.id];
+            if (c === undefined || c === "error")
+                return true;
+            if (c === "loading")
+                return false;
+            return !c.complete;
+        });
+        if (toStart.length === 0)
+            return;
+        setSubitemCounts((prev) => {
+            const next = { ...prev };
+            for (const d of toStart)
+                next[d.id] = "loading";
+            return next;
+        });
+        for (const descriptor of toStart) {
+            const controller = new AbortController();
+            inFlight.set(descriptor.id, controller);
+            void (async () => {
+                try {
+                    const finalCount = await streamSubitemCount({ itemId: descriptor.id, language: descriptor.language }, ({ count, complete }) => {
+                        setSubitemCounts((prev) => ({
+                            ...prev,
+                            [descriptor.id]: { count, complete },
+                        }));
+                    }, { sessionId, signal: controller.signal });
+                    // Backend may close the stream without explicitly sending
+                    // complete=true on the last line — mark complete on a clean exit.
+                    setSubitemCounts((prev) => {
+                        const existing = prev[descriptor.id];
+                        const count = existing && typeof existing === "object"
+                            ? existing.count
+                            : finalCount;
+                        return {
+                            ...prev,
+                            [descriptor.id]: { count, complete: true },
+                        };
+                    });
+                }
+                catch (err) {
+                    if (err?.name === "AbortError")
+                        return;
+                    setSubitemCounts((prev) => {
+                        // Don't overwrite a partial count with "error" — keep what we have.
+                        const existing = prev[descriptor.id];
+                        if (existing && typeof existing === "object")
+                            return prev;
+                        return { ...prev, [descriptor.id]: "error" };
+                    });
+                }
+                finally {
+                    if (inFlight.get(descriptor.id) === controller) {
+                        inFlight.delete(descriptor.id);
+                    }
+                }
+            })();
+        }
+    }, [items, subitemCounts, sessionId]);
+    // Abort any in-flight streams on unmount.
+    useEffect(() => {
+        const inFlight = inFlightRef.current;
+        return () => {
+            for (const ctrl of inFlight.values())
+                ctrl.abort();
+            inFlight.clear();
+        };
+    }, []);
+    const cacheTreeNode = useCallback((node) => {
+        const id = node.id;
+        if (!id)
+            return;
+        const cache = itemCacheRef.current;
+        if (cache.has(id))
+            return;
+        const anyNode = node;
+        cache.set(id, fullItemFromDescriptor({
+            id,
+            language: node.language ?? language,
+            version: node.version ?? 1,
+            name: node.name,
+            displayName: node.displayName,
+            path: node.path,
+            idPath: anyNode.idPath,
+            icon: anyNode.icon,
+            templateId: anyNode.templateId,
+            hasChildren: anyNode.hasChildren,
+        }));
+    }, [language]);
+    const handleAddToList = useCallback(async (itemsToAdd) => {
+        const source = itemsToAdd ?? selectedInTree;
+        if (!source || source.length === 0)
+            return;
+        const existing = new Set(items.map((i) => i.descriptor.id));
+        const next = [...items];
+        for (const node of source) {
+            if (!node.id || existing.has(node.id))
+                continue;
+            cacheTreeNode(node);
+            next.push({
+                descriptor: {
+                    id: node.id,
+                    language: node.language ?? language,
+                    version: node.version ?? 1,
+                    name: node.name,
+                    displayName: node.displayName,
+                    path: node.path,
+                },
+                includeSubitems: false,
+            });
+            existing.add(node.id);
+        }
+        setItems(next);
+        commitToWizard(next);
+        setSelectedInTree([]);
+        setSelectedFromList([]);
+    }, [items, selectedInTree, language, cacheTreeNode, commitToWizard]);
+    const handleAddItem = useCallback(async (item) => {
+        const id = item.id;
+        if (!id || items.some((i) => i.descriptor.id === id))
+            return;
+        cacheTreeNode(item);
+        const next = [
+            ...items,
+            {
+                descriptor: {
+                    id,
+                    language: item.language ?? language,
+                    version: item.version ?? 1,
+                    name: item.name,
+                    displayName: item.displayName,
+                    path: item.path,
+                },
+                includeSubitems: false,
+            },
+        ];
+        setItems(next);
+        commitToWizard(next);
+        setSelectedFromList([]);
+    }, [items, language, cacheTreeNode, commitToWizard]);
+    const handleRemoveFromList = useCallback(() => {
+        const ids = new Set(selectedFromList.map((i) => i.descriptor.id));
+        const next = items.filter((i) => !ids.has(i.descriptor.id));
+        setItems(next);
+        commitToWizard(next);
+        setSelectedFromList([]);
+    }, [items, selectedFromList, commitToWizard]);
+    const handleRemoveItem = useCallback((index) => {
+        const next = items.filter((_, i) => i !== index);
+        setItems(next);
+        commitToWizard(next);
+        setSelectedFromList([]);
+    }, [items, commitToWizard]);
+    const handleToggleSubitems = useCallback((index) => {
+        const next = items.map((it, i) => i === index ? { ...it, includeSubitems: !it.includeSubitems } : it);
+        setItems(next);
+        commitToWizard(next);
+    }, [items, commitToWizard]);
+    return (_jsx(ItemCollectionEditor, { items: items, selectedInTree: selectedInTree, onSelectedInTreeChange: setSelectedInTree, selectedFromList: selectedFromList, onSelectedFromListChange: setSelectedFromList, onAddToList: handleAddToList, onRemoveFromList: handleRemoveFromList, onAddItem: handleAddItem, onRemoveItem: handleRemoveItem, onToggleSubitems: handleToggleSubitems, language: language, rootItemIds: [SITECORE_ROOT], selectedItemsLabel: "Items to Translate", emptyMessage: "No items selected", emptyHint: "Browse or search to add items", height: height, subitemCounts: subitemCounts, expandIdPath: expandIdPath, localStorageKey: "translation-wizard.itemCollectionSplitter" }));
+}

package/dist/steps/MetadataInputStep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetadataInputStep.d.ts","sourceRoot":"","sources":["../../src/steps/MetadataInputStep.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,8CAA8C;AAC9C,wBAAgB,iBAAiB,CAAC,EAChC,SAAS,EACT,QAAe,EACf,IAAI,EACJ,OAAO,EACP,eAAe,GAChB,EAAE,oBAAoB,2CA8EtB"}
+{"version":3,"file":"MetadataInputStep.d.ts","sourceRoot":"","sources":["../../src/steps/MetadataInputStep.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,8CAA8C;AAC9C,wBAAgB,iBAAiB,CAAC,EAChC,SAAS,EACT,QAAe,EACf,IAAI,EACJ,OAAO,EACP,eAAe,GAChB,EAAE,oBAAoB,2CAsFtB"}

package/dist/steps/MetadataInputStep.js

@@ -10,7 +10,14 @@ export function MetadataInputStep({ stepIndex, isActive = true, data, setData, o
         });
         return result;
     });
-    const allItems = data.includeSubitems ? data.discoveredItems : data.items;
+    // Prefer the user's tree selection (per-item subitem flags) when present,
+    // otherwise the legacy expanded list, otherwise the initial wizard items.
+    const allItems = (data.selectionTreeItems && data.selectionTreeItems.length > 0
+        ? data.selectionTreeItems.map((entry) => entry.descriptor)
+        : null) ??
+        (data.discoveredItems && data.discoveredItems.length > 0
+            ? data.discoveredItems
+            : data.items);
     const handleMetadataChange = (itemId, language, metadata) => {
         const updated = {
             ...itemMetadata,

package/dist/steps/PromptCustomizationStep.d.ts

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

package/dist/steps/PromptCustomizationStep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PromptCustomizationStep.d.ts","sourceRoot":"","sources":["../../src/steps/PromptCustomizationStep.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAyB,MAAM,SAAS,CAAC;AAEtE,wBAAgB,uBAAuB,CAAC,EACtC,SAAS,EACT,QAAe,EACf,IAAI,EACJ,OAAO,EACP,eAAe,EACf,WAAW,GACZ,EAAE,oBAAoB,2CAqRtB"}
+{"version":3,"file":"PromptCustomizationStep.d.ts","sourceRoot":"","sources":["../../src/steps/PromptCustomizationStep.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAyB,MAAM,SAAS,CAAC;AAItE,wBAAgB,uBAAuB,CAAC,EACtC,QAAe,EACf,IAAI,EACJ,OAAO,EACP,eAAe,EACf,WAAW,GACZ,EAAE,oBAAoB,2CAqctB"}