@agility/cli
Version:
Agility CLI for working with your content. (Public Beta)
117 lines (116 loc) • 4.47 kB
TypeScript
import { SitemapNode, PageHierarchy, HierarchicalPageGroup } from '../../../types/syncAnalysis';
/**
* Load and parse sitemap hierarchy for hierarchical page chain analysis
*/
export declare class SitemapHierarchy {
constructor();
loadAllSitemaps(guid: string, locale: string): {
[key: string]: SitemapNode[] | null;
};
/**
* Load nested sitemap from the file system
*/
loadNestedSitemap(filePath: string): SitemapNode[] | null;
/**
* Build page hierarchy map from nested sitemap
*/
buildPageHierarchy(sitemap: SitemapNode[]): PageHierarchy;
/**
* Group pages hierarchically based on sitemap structure
*/
groupPagesHierarchically(pages: any[], hierarchy: PageHierarchy): HierarchicalPageGroup[];
/**
* Find the parent page ID for a given page (only if parent exists in our page list)
*/
private findParentPageId;
/**
* Build a hierarchical group starting from a root page
*/
private buildHierarchicalGroup;
/**
* Collect all descendants with unlimited nesting levels (not just direct children)
* This enables proper display of deep hierarchies like PageID:A → PageID:B → PageID:C
*/
private collectAllDescendants;
/**
* Get orphaned pages (pages not in any hierarchical group)
*/
getOrphanedPages(pages: any[], hierarchicalGroups: HierarchicalPageGroup[]): any[];
/**
* Debug: Log hierarchy structure
*/
debugLogHierarchy(hierarchy: PageHierarchy): void;
/**
* ✅ NEW: Find page parent from source sitemap with comprehensive lookup
* Handles both template pages and dynamic page instances
*/
findPageParentInSourceSitemap(pageId: number, pageName: string, channelName: string): {
parentId: number | null;
parentName: string | null;
foundIn: string;
};
/**
* ✅ NEW: Enhanced hierarchy build that handles dynamic pages correctly
*/
buildPageHierarchyWithDynamicSupport(sitemap: SitemapNode[]): PageHierarchy;
/**
* Calculate depth level for each page in the hierarchy
* Depth 0 = root pages (no parents), Depth 1 = direct children, etc.
*/
calculatePageDepths(pages: any[], hierarchy: PageHierarchy): Map<number, number>;
/**
* Get pages grouped by depth level
* Returns map of depth → pages at that depth
*/
getPagesByDepth(pages: any[], pageDepths: Map<number, number>): Map<number, any[]>;
/**
* Generate dependency-safe page processing order
* Returns pages ordered by depth (shallowest first) so parents are processed before children
*/
getProcessingOrder(pages: any[], hierarchy: PageHierarchy): {
orderedPages: any[];
depthInfo: Map<number, number>;
};
/**
* Validate page processing order is dependency-safe
* Ensures no page is processed before its parent
*/
validateProcessingOrder(orderedPages: any[], hierarchy: PageHierarchy): boolean;
/**
* Extract sibling ordering information from source sitemap
* Returns a map of pageID → nextSiblingPageID for proper insertion order
*/
extractSiblingOrderFromSitemap(sitemap: SitemapNode[]): Map<number, number | null>;
/**
* Get the pageID that should come BEFORE the specified page (for insertBefore parameter)
* FIXED: Returns the NEXT sibling (what this page should go before), not the previous sibling
*/
getInsertBeforePageId(pageId: number, siblingOrder: Map<number, number | null>): number | null;
/**
* Build comprehensive page ordering data including parent-child and sibling relationships
*/
buildPageOrderingData(sitemap: SitemapNode[]): {
hierarchy: PageHierarchy;
siblingOrder: Map<number, number | null>;
parentToChildrenMap: Map<number, number[]>;
};
/**
* Get processing order that preserves both parent-child dependencies AND sibling order
*/
getOrderedProcessingSequence(pages: any[], sitemap: SitemapNode[]): {
orderedPages: any[];
orderingData: {
hierarchy: PageHierarchy;
siblingOrder: Map<number, number | null>;
parentToChildrenMap: Map<number, number[]>;
};
};
/**
* Sort pages by their sibling order from the sitemap
*/
private sortPagesBySiblingOrder;
/**
* Get parent page ID for a given page
*/
private getParentPageId;
}