"use strict";
exports.id = 68;
exports.ids = [68];
exports.modules = {

/***/ 69068:
/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {


// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape@3.26.0/node_modules/cytoscape/dist/cytoscape.cjs.js
var cytoscape_cjs = __webpack_require__(10453);
// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape-dagre@2.5.0_cytoscape@3.26.0/node_modules/cytoscape-dagre/cytoscape-dagre.js
var cytoscape_dagre = __webpack_require__(24777);
;// CONCATENATED MODULE: ../utils-graph/dist/styles/node.js
const node_fontSize = 24;
const node_fontFamily = 'Fira Code';
const node_fontWeight = 600;
const node_nodeStyles = [
    {
        selector: 'node',
        style: {
            label: 'data(id)',
            width: 'data(width)',
            height: 'data(height)',
            shape: 'roundrectangle',
            'text-margin-x': 20,
            'background-height': 42,
            'background-width': 42,
            'background-position-x': '24px',
            'background-position-y': '16px',
            'background-image': 'data(image)',
            'font-size': node_fontSize,
            'font-family': node_fontFamily,
            'font-weight': node_fontWeight,
            'background-color': '#f4f4f5',
            color: '#27272a',
            'border-width': 1,
            'border-style': 'solid',
            'border-color': '#e4e4e7',
            'text-halign': 'center',
            'text-valign': 'center',
            'overlay-opacity': 0,
        },
    },
    {
        selector: 'node.dim',
        style: {
            opacity: 0.2,
        },
    },
    {
        selector: 'node.hover',
        style: {
            'background-color': '#09090b',
            color: '#FFF',
            'border-color': '#09090b',
        },
    },
    {
        selector: 'node.dark',
        style: {
            'background-color': '#27272a',
            'border-color': '#3f3f46',
            color: '#fff',
        },
    },
];

// EXTERNAL MODULE: ../utils-graph/dist/styles/edge.js
var edge = __webpack_require__(70982);
// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape-popper@2.0.0_cytoscape@3.26.0/node_modules/cytoscape-popper/cytoscape-popper.js
var cytoscape_popper = __webpack_require__(59286);
;// CONCATENATED MODULE: ../utils-graph/dist/create-render-graph.js





cytoscape_cjs.use(cytoscape_dagre);
cytoscape_cjs.use(cytoscape_popper);
/**
 * Calculates the minZoom value based on the length of the elements array.
 */
const calculateMinZoom = (elementsLength) => {
    const minZoomBase = 0.1; // Change this value to set the minimum zoom level when the array is empty
    const minZoomFactor = 0.000115; // Change this value to control the rate at which minZoom decreases as the array length increases
    return minZoomBase - elementsLength * minZoomFactor;
};
/**
 * Creates and renders a graph.
 */
const createRenderGraph = ({ container, elements, }) => {
    const renderGraph = cytoscape({
        container,
        style: [...nodeStyles, ...edgeStyles],
        autoungrabify: true,
        maxZoom: 2,
        minZoom: calculateMinZoom(elements.length),
        elements,
    });
    return renderGraph;
};

// EXTERNAL MODULE: ../utils-core/dist/index.js + 1 modules
var dist = __webpack_require__(53771);
;// CONCATENATED MODULE: ../utils-graph/dist/get-element-definitions.js


const nodeImage = ' ';
const reactLogo = 'PHN2ZyB3aWR0aD0iMzYiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCAzNiAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzBfMykiPgo8cGF0aCBkPSJNMTggMjEuMTA1NUMxOS43NzIxIDIxLjEwNTUgMjEuMjA4NyAxOS43MTUxIDIxLjIwODcgMThDMjEuMjA4NyAxNi4yODQ5IDE5Ljc3MjEgMTQuODk0NSAxOCAxNC44OTQ1QzE2LjIyNzkgMTQuODk0NSAxNC43OTEzIDE2LjI4NDkgMTQuNzkxMyAxOEMxNC43OTEzIDE5LjcxNTEgMTYuMjI3OSAyMS4xMDU1IDE4IDIxLjEwNTVaIiBmaWxsPSIjNjFEQUZCIi8+CjxwYXRoIGQ9Ik0xOCAyNC4zNjI2QzI3LjUwODkgMjQuMzYyNiAzNS4yMTc0IDIxLjUxMzkgMzUuMjE3NCAxOEMzNS4yMTc0IDE0LjQ4NjEgMjcuNTA4OSAxMS42Mzc1IDE4IDExLjYzNzVDOC40OTExMSAxMS42Mzc1IDAuNzgyNjIzIDE0LjQ4NjEgMC43ODI2MjMgMThDMC43ODI2MjMgMjEuNTEzOSA4LjQ5MTExIDI0LjM2MjYgMTggMjQuMzYyNloiIHN0cm9rZT0iIzYxREFGQiIvPgo8cGF0aCBkPSJNMTIuMzA2OCAyMS4xODEzQzE3LjA2MTMgMjkuMTUxNSAyMy40NjQ1IDM0LjE4ODMgMjYuNjA4NyAzMi40MzEzQzI5Ljc1MyAzMC42NzQzIDI4LjQ0NzcgMjIuNzg4OSAyMy42OTMyIDE0LjgxODdDMTguOTM4NyA2Ljg0ODUzIDEyLjUzNTYgMS44MTE3MyA5LjM5MTMzIDMuNTY4N0M2LjI0NzA3IDUuMzI1NjcgNy41NTI0IDEzLjIxMTEgMTIuMzA2OCAyMS4xODEzWiIgc3Ryb2tlPSIjNjFEQUZCIi8+CjxwYXRoIGQ9Ik0xMi4zMDY4IDE0LjgxODdDNy41NTIzOCAyMi43ODg5IDYuMjQ3MDYgMzAuNjc0MyA5LjM5MTMxIDMyLjQzMTNDMTIuNTM1NiAzNC4xODgzIDE4LjkzODcgMjkuMTUxNSAyMy42OTMyIDIxLjE4MTNDMjguNDQ3NiAxMy4yMTExIDI5Ljc1MyA1LjMyNTY2IDI2LjYwODcgMy41Njg2OUMyMy40NjQ0IDEuODExNzIgMTcuMDYxMyA2Ljg0ODUzIDEyLjMwNjggMTQuODE4N1oiIHN0cm9rZT0iIzYxREFGQiIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzBfMyI+CjxyZWN0IHdpZHRoPSIzNiIgaGVpZ2h0PSIzMSIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDAgMi41KSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=';
const nextLogo = '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';
const ImageByPrimaryDependency = {
    [dist/* PackageType */.yR.REACT]: reactLogo,
    [dist/* PackageType */.yR.NODE]: nodeImage,
    [dist/* PackageType */.yR.NEXT]: nextLogo,
};
const getNodeSize = ({ context, name, }) => {
    if (!context)
        return;
    context.font = `normal ${fontWeight} ${fontSize}px ${fontFamily}`;
    const paddingY = 24;
    const paddingX = 24;
    const iconWidth = 50;
    const labelWidth = context.measureText(name).width;
    const paddedLabelWidth = labelWidth + paddingX * 2 + iconWidth;
    const paddedLabelHeight = fontSize + paddingY * 2;
    return {
        width: Math.ceil(paddedLabelWidth),
        height: Math.ceil(paddedLabelHeight),
    };
};
const getElementDefinitions = ({ dependencies, packages, }) => {
    if (typeof document === 'undefined')
        return [];
    try {
        const canvas = document.createElement('canvas');
        const context = canvas.getContext('2d');
        const nodes = packages.map((package_) => {
            const dimensions = getNodeSize({ context, name: package_.name });
            const image = ImageByPrimaryDependency[package_.type] ?? nodeImage;
            const imageData = 'data:image/svg+xml;base64,' + image;
            return {
                data: {
                    ...package_,
                    id: package_.name,
                    image: imageData,
                    ...dimensions,
                },
            };
        });
        const edges = dependencies.map((dep) => {
            return {
                data: {
                    ...dep,
                    id: `${dep.source}->${dep.target}`,
                },
            };
        });
        return [...nodes, ...edges];
    }
    catch (error) {
        console.error(error);
        return [];
    }
};

;// CONCATENATED MODULE: ../utils-graph/dist/layout-options.js
const layoutOptions = {
    name: 'dagre',
    animate: false,
    rankSep: 240,
    nodeSep: 140,
    nodeDimensionsIncludeLabels: true,
};

;// CONCATENATED MODULE: ../utils-graph/dist/get-updated-graph-json.js





cytoscape_cjs.use(cytoscape_dagre);
const getElementDefinitionsWithUpdatedLayout = async ({ elements }) => {
    const graph = cytoscape_cjs({
        styleEnabled: true,
        style: [...node_nodeStyles, ...edge/* edgeStyles */.E],
        elements,
    });
    graph.layout(layoutOptions).run();
    return graph.elements().jsons();
};

;// CONCATENATED MODULE: ../utils-graph/dist/bind-render-graph-events.js

/**********************************
 *            NODES               *
 **********************************/
const handleNodeMouseover = ({ target, renderGraph, }) => {
    const neighborhood = target.closedNeighborhood();
    renderGraph
        ?.elements()
        .difference(neighborhood)
        .filter((ele) => {
        return !ele.selected();
    })
        .addClass('dim');
    const forceEdgeColor = renderGraph.scratch('forceEdgeColor');
    if (!forceEdgeColor) {
        target.connectedEdges().map((element) => {
            const type = element.data('type');
            element.addClass(type);
        });
    }
    target.addClass('hover');
};
const handleNodeMouseout = ({ target, renderGraph, }) => {
    const neighborhood = target.neighborhood();
    const focusedElements = renderGraph.collection([neighborhood, target]);
    renderGraph?.elements().difference(focusedElements).removeClass('dim');
    const forceEdgeColor = renderGraph.scratch('forceEdgeColor');
    if (!forceEdgeColor) {
        target.connectedEdges().map((element) => {
            element.removeClass([
                DependencyType.PRODUCTION,
                DependencyType.DEVELOPMENT,
                DependencyType.PEER,
            ]);
        });
    }
    target.removeClass('hover');
};
/**********************************
 *            EDGES               *
 **********************************/
const handleEdgeMouseover = ({ target, renderGraph, violations = [], }) => {
    const forceEdgeColor = renderGraph.scratch('forceEdgeColor');
    target.addClass('hover');
    if (forceEdgeColor)
        return;
    const type = target.data('type');
    const sourcePackageName = target.source().id();
    const targetPackageName = target.target().id();
    const hasViolation = violations.some((violation) => {
        return (violation.sourcePackageName === sourcePackageName &&
            violation.targetPackageName === targetPackageName);
    });
    if (!hasViolation) {
        target.addClass(type);
    }
};
const handleEdgeMouseout = ({ target, renderGraph, }) => {
    const forceEdgeColor = renderGraph.scratch('forceEdgeColor');
    target.removeClass('hover');
    if (forceEdgeColor)
        return;
    target.removeClass([
        DependencyType.PRODUCTION,
        DependencyType.DEVELOPMENT,
        DependencyType.PEER,
    ]);
};
/**********************************
 *         GENERAL               *
 **********************************/
const bind_render_graph_events_bindRenderGraphEvents = (arguments_) => {
    const { renderGraph } = arguments_;
    renderGraph
        .nodes()
        .on('mouseover', (event) => handleNodeMouseover({ ...arguments_, target: event.target }));
    renderGraph
        .nodes()
        .on('mouseout', (event) => handleNodeMouseout({ ...arguments_, target: event.target }));
    renderGraph
        .edges()
        .on('mouseover', (event) => handleEdgeMouseover({ ...arguments_, target: event.target }));
    renderGraph
        .edges()
        .on('mouseout', (event) => handleEdgeMouseout({ ...arguments_, target: event.target }));
};

;// CONCATENATED MODULE: ../utils-graph/dist/render-elements-to-graph.js
'use client';


const updateStyles = ({ graph, theme, forceEdgeColor, violations = [], }) => {
    graph.elements().removeClass(['dark', 'light']).addClass(theme);
    for (const edge of graph.edges()) {
        const edgeData = edge.data();
        const violationForEdge = edgeData
            ? violations.find((violation) => {
                const source = edge.source().data();
                const target = edge.target().data();
                return (violation.sourcePackageName === source.name &&
                    violation.targetPackageName === target.name);
            })
            : undefined;
        if (forceEdgeColor) {
            edge.addClass(edgeData.type);
            edge.addClass('focus');
        }
        else {
            edge.removeClass([
                DependencyType.DEVELOPMENT,
                DependencyType.PEER,
                DependencyType.PRODUCTION,
            ]);
            edge.removeClass('focus');
        }
        if (violationForEdge) {
            edge.removeClass([
                DependencyType.DEVELOPMENT,
                DependencyType.PEER,
                DependencyType.PRODUCTION,
            ]);
            edge.removeClass('focus');
            edge.addClass('violation');
        }
    }
};
const updateGraphElements = async ({ renderGraph, traversalGraph, theme, forceEdgeColor, violations, elements, }) => {
    // Clear the graph
    renderGraph.json({ elements });
    updateStyles({ graph: renderGraph, theme, forceEdgeColor, violations });
    renderGraph.fit(undefined, 24);
    // Bind graph events, these events are all fired by the Cytoscape library
    bindRenderGraphEvents({
        renderGraph,
        theme,
        traversalGraph,
        violations,
    });
};


;// CONCATENATED MODULE: ../utils-graph/dist/create-traversal-graph.js

const createTraversalGraph = ({ elements, }) => cytoscape({
    headless: true,
    elements,
});

;// CONCATENATED MODULE: ../utils-graph/dist/actions.js
function withSerialization(function_) {
    return (arguments_) => {
        const result = function_(arguments_);
        return result.jsons();
    };
}
const show = withSerialization(({ traversalGraph, renderGraph, selector, }) => {
    // eslint-disable-next-line unicorn/no-array-callback-reference
    const matchingNodes = traversalGraph.nodes().filter(selector);
    const existingNodes = renderGraph.nodes();
    const nodesToRender = existingNodes.union(matchingNodes);
    const edgesToRender = nodesToRender.nodes().edgesTo(nodesToRender.nodes());
    const elementsToRender = nodesToRender.union(edgesToRender);
    return elementsToRender;
});
const showDependencies = withSerialization(({ traversalGraph, renderGraph, id, }) => {
    const node = traversalGraph.$id(id);
    const nodeAndDependants = node.union(node.outgoers());
    const elementsToRender = renderGraph.elements().union(nodeAndDependants);
    return elementsToRender;
});
const showDependants = withSerialization(({ traversalGraph, renderGraph, id, }) => {
    const node = traversalGraph.$id(id);
    const nodeAndDependants = node.union(node.incomers());
    const nodesToRender = nodeAndDependants.nodes();
    const edgesToRender = nodesToRender.edgesTo(nodesToRender);
    const elementsToRender = renderGraph
        .elements()
        .union(nodesToRender)
        .union(edgesToRender);
    return elementsToRender;
});
const setInitialElements = withSerialization(({ renderGraph }) => {
    return renderGraph.elements();
});
const actions_focus = withSerialization(({ traversalGraph, selector, }) => {
    // eslint-disable-next-line unicorn/no-array-callback-reference
    const matchingNodes = traversalGraph.nodes().filter(selector);
    const edgesToRender = matchingNodes.edgesTo(matchingNodes);
    return traversalGraph
        .collection()
        .union(matchingNodes)
        .union(edgesToRender);
});
const showAll = withSerialization(({ traversalGraph }) => {
    return traversalGraph.elements();
});
const hideAll = withSerialization(({ traversalGraph }) => {
    return traversalGraph.collection();
});
const hideDependents = withSerialization(({ traversalGraph, renderGraph, id, }) => {
    const successorsOfNode = renderGraph.$id(id).successors();
    const successorsOfDirectDependents = traversalGraph
        .$id(id)
        .incomers()
        .successors();
    return successorsOfDirectDependents.length > 0
        ? traversalGraph
            .collection()
            .union(traversalGraph.$id(id))
            .union(successorsOfNode)
            .intersection(successorsOfDirectDependents)
        : renderGraph.elements();
});
const hideDependencies = withSerialization(({ traversalGraph, renderGraph, id, }) => {
    const elementsToHide = traversalGraph.$id(id).successors();
    return renderGraph.elements().difference(elementsToHide);
});
const hide = withSerialization(({ traversalGraph, renderGraph, selector, }) => {
    const elementsToHide = traversalGraph.collection();
    // eslint-disable-next-line unicorn/no-array-callback-reference
    const matchingNodes = traversalGraph.nodes().filter(selector);
    const edgesForElements = matchingNodes.connectedEdges();
    elementsToHide.merge(matchingNodes).merge(edgesForElements);
    return renderGraph.elements().difference(elementsToHide);
});

;// CONCATENATED MODULE: ../utils-graph/dist/constants/query-keys.js
const metadataKey = 'metadata';
const documentsKeys = [metadataKey, 'documents'];
const violationsKeys = [metadataKey, 'violations'];
const tagsKeys = [metadataKey, 'tags'];
const projectConfigKeys = [metadataKey, 'projectConfig'];
const constraintsKeys = [metadataKey, 'constraints'];
const codeownersKeys = [metadataKey, 'codeowners'];
const packagesKeys = [metadataKey, 'packages'];
const dependenciesKeys = [metadataKey, 'dependencies'];

;// CONCATENATED MODULE: ../utils-graph/dist/index.js








;// CONCATENATED MODULE: ../data-graph-worker/dist/index.js

addEventListener('message', async (event) => {
    const updatedElelementDefinitions = await getElementDefinitionsWithUpdatedLayout({
        elements: event.data,
    });
    try {
        postMessage(updatedElelementDefinitions);
    }
    catch (error) {
        console.error(error);
    }
});

;// CONCATENATED MODULE: ./src/app/worker.ts



/***/ }),

/***/ 53771:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {


// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  D1: () => (/* reexport */ DependencyType),
  yR: () => (/* reexport */ PackageType)
});

// UNUSED EXPORTS: AllPackagesWildcard, Lockfile, PackageManager, Theme, formatPackageName, formatTagName, slugifyPackageName, slugifyTagName

;// CONCATENATED MODULE: ../utils-core/dist/constants.js
var Theme;
(function (Theme) {
    Theme["Dark"] = "dark";
    Theme["Light"] = "light";
    Theme["System"] = "system";
})(Theme || (Theme = {}));
var Lockfile;
(function (Lockfile) {
    Lockfile["NPM_LOCKFILE"] = "package-lock.json";
    Lockfile["YARN_LOCKFILE"] = "yarn.lock";
    Lockfile["PNPM_LOCKFILE"] = "pnpm-lock.yaml";
})(Lockfile || (Lockfile = {}));
var DependencyType;
(function (DependencyType) {
    DependencyType["PEER"] = "peer";
    DependencyType["DEVELOPMENT"] = "development";
    DependencyType["PRODUCTION"] = "production";
})(DependencyType || (DependencyType = {}));
var PackageType;
(function (PackageType) {
    PackageType["NODE"] = "node";
    PackageType["REACT"] = "react";
    PackageType["NEXT"] = "next";
})(PackageType || (PackageType = {}));
var PackageManager;
(function (PackageManager) {
    PackageManager["PNPM"] = "pnpm";
    PackageManager["YARN"] = "yarn";
    PackageManager["NPM"] = "npm";
})(PackageManager || (PackageManager = {}));
const AllPackagesWildcard = '*';

;// CONCATENATED MODULE: ../utils-core/dist/index.js







/***/ })

};
;