Method init

src/TraversionGraph.ts:136–230

* Initializes the traversion graph based on the supported formats and handlers. This should be called after all handlers have been registered and their supported formats have been cached in window.supportedFormatCache. The graph is built by creating nodes for each unique file format and edges for ea

(supportedFormatCache: Map<string, FileFormat[]>, handlers: FormatHandler[], strictCategories: boolean = false)

     * @param strictCategories If true, the algorithm will apply category change costs more strictly, even when formats share categories. This can lead to more accurate pathfinding at the cost of potentially longer paths and increased search time. If false, category change costs will only be applied when formats do not share any categories, allowing for more flexible pathfinding that may yield shorter paths but with less nuanced cost calculations.
     */
    public init(supportedFormatCache: Map<string, FileFormat[]>, handlers: FormatHandler[], strictCategories: boolean = false) {
        this.handlers = handlers;
        this.nodes.length = 0;
        this.edges.length = 0;

        console.log("Initializing traversion graph...");
        const startTime = performance.now();

        let handlerIndex = 0;
        supportedFormatCache.forEach((formats, handler) => {
            let fromIndices: Array<{format: FileFormat, index: number}> = [];
            let toIndices: Array<{format: FileFormat, index: number}> = [];
            formats.forEach(format => {
                const formatIdentifier = format.mime + `(${format.format})`;
                let index = this.nodes.findIndex(node => node.identifier === formatIdentifier);
                if (index === -1) {
                    index = this.nodes.length;
                    this.nodes.push({
                        identifier: formatIdentifier,
                        format: format,
                        edges: []
                    });
                }
                if (format.from) fromIndices.push({format, index});
                if (format.to) toIndices.push({format, index});
            });
            fromIndices.forEach(from => {
                toIndices.forEach(to => {
                    if (from.index === to.index) return; // No self-loops
                    this.edges.push({
                        from: from,
                        to: to,
                        handler: handler,
                        cost: this.costFunction(
                            from,
                            to,
                            strictCategories,
                            handler,
                            handlerIndex
                        )
                    });
                    this.nodes[from.index].edges.push(this.edges.length - 1);
                });
            });
            handlerIndex++;
        });

        // Add edges for handlers with supportAnyInput.
        // These handlers can accept any format as input, so we create edges
        // from every known format node to their output formats.
        handlers.forEach((handler, hIndex) => {
            if (!handler.supportAnyInput) return;
            const formats = supportedFormatCache.get(handler.name);
            if (!formats) return;

            // Collect output format node indices for this handler
            const toEntries: Array<{format: FileFormat, index: number}> = [];
            for (const f of formats) {