@principal-ai/file-city-react 0.3.0

package/dist/builder/cityDataUtils.d.ts

@@ -0,0 +1,15 @@
+import { CityData, SelectiveRenderOptions } from '@principal-ai/file-city-builder';
+export declare const filterCityDataForSelectiveRender: (cityData: CityData, selectiveRender?: SelectiveRenderOptions) => CityData;
+/**
+ * Filter city data to only include a subdirectory and optionally remap coordinates
+ * to make the subdirectory the new origin (0,0)
+ */
+export declare const filterCityDataForSubdirectory: (cityData: CityData, subdirectoryPath: string, autoCenter?: boolean) => CityData;
+/**
+ * Filter city data based on multiple directory filters with include/exclude modes
+ */
+export declare const filterCityDataForMultipleDirectories: (cityData: CityData, filters: Array<{
+    path: string;
+    mode: "include" | "exclude";
+}>, autoCenter?: boolean, combineMode?: "union" | "intersection") => CityData;
+//# sourceMappingURL=cityDataUtils.d.ts.map

package/dist/builder/cityDataUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cityDataUtils.d.ts","sourceRoot":"","sources":["../../src/builder/cityDataUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAER,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AAGzC,eAAO,MAAM,gCAAgC,GAC3C,UAAU,QAAQ,EAClB,kBAAkB,sBAAsB,KACvC,QAqBF,CAAC;AA6GF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,GACxC,UAAU,QAAQ,EAClB,kBAAkB,MAAM,EACxB,aAAY,OAAc,KACzB,QA6HF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oCAAoC,GAC/C,UAAU,QAAQ,EAClB,SAAS,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC,EAC7D,aAAY,OAAc,EAC1B,cAAa,OAAO,GAAG,cAAwB,KAC9C,QAiJF,CAAC"}

package/dist/builder/cityDataUtils.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterCityDataForMultipleDirectories = exports.filterCityDataForSubdirectory = exports.filterCityDataForSelectiveRender = void 0;
+// Utility functions for selective rendering
+const filterCityDataForSelectiveRender = (cityData, selectiveRender) => {
+    if (!selectiveRender || selectiveRender.mode === 'all') {
+        return cityData;
+    }
+    const { mode, directories, rootDirectory, showParentContext } = selectiveRender;
+    switch (mode) {
+        case 'filter':
+            return filterCityData(cityData, directories || new Set());
+        case 'focus':
+            // Focus mode doesn't filter data, just affects rendering
+            return cityData;
+        case 'drilldown':
+            return drilldownCityData(cityData, rootDirectory || '', showParentContext || false);
+        default:
+            return cityData;
+    }
+};
+exports.filterCityDataForSelectiveRender = filterCityDataForSelectiveRender;
+const filterCityData = (cityData, visibleDirectories) => {
+    const filteredBuildings = cityData.buildings.filter(building => {
+        // Check if building is in any of the visible directories
+        return Array.from(visibleDirectories).some(dir => building.path.startsWith(dir + '/') || building.path === dir);
+    });
+    const filteredDistricts = cityData.districts.filter(district => {
+        // Include district if it's in the visible set or is a parent of a visible directory
+        return Array.from(visibleDirectories).some(dir => district.path === dir ||
+            dir.startsWith(district.path + '/') ||
+            district.path.startsWith(dir + '/'));
+    });
+    return {
+        ...cityData,
+        buildings: filteredBuildings,
+        districts: filteredDistricts,
+        bounds: recalculateBounds(filteredBuildings, filteredDistricts),
+    };
+};
+const drilldownCityData = (cityData, rootDirectory, showParentContext) => {
+    if (!rootDirectory)
+        return cityData;
+    // Filter buildings to only those within the root directory
+    const filteredBuildings = cityData.buildings
+        .filter(building => building.path.startsWith(rootDirectory + '/') || building.path === rootDirectory)
+        .map(building => ({
+        ...building,
+        // Adjust path to be relative to the new root
+        path: building.path.startsWith(rootDirectory + '/')
+            ? building.path.substring(rootDirectory.length + 1)
+            : building.path,
+    }));
+    // Filter districts to only those within the root directory
+    const filteredDistricts = cityData.districts
+        .filter(district => district.path.startsWith(rootDirectory + '/') || district.path === rootDirectory)
+        .map(district => ({
+        ...district,
+        // Adjust path to be relative to the new root
+        path: district.path.startsWith(rootDirectory + '/')
+            ? district.path.substring(rootDirectory.length + 1)
+            : district.path === rootDirectory
+                ? ''
+                : district.path,
+    }));
+    // If showing parent context, add immediate parent district
+    if (showParentContext && rootDirectory) {
+        const parentPath = rootDirectory.split('/').slice(0, -1).join('/');
+        const parentDistrict = cityData.districts.find(d => d.path === parentPath);
+        if (parentDistrict) {
+            filteredDistricts.unshift({
+                ...parentDistrict,
+                path: '../' + parentDistrict.path.split('/').pop(),
+            });
+        }
+    }
+    return {
+        ...cityData,
+        buildings: filteredBuildings,
+        districts: filteredDistricts,
+        bounds: recalculateBounds(filteredBuildings, filteredDistricts),
+        metadata: {
+            ...cityData.metadata,
+            rootPath: rootDirectory,
+        },
+    };
+};
+const recalculateBounds = (buildings, districts) => {
+    if (buildings.length === 0 && districts.length === 0) {
+        return { minX: 0, maxX: 100, minZ: 0, maxZ: 100 };
+    }
+    const allX = [
+        ...buildings.map(b => b.position.x),
+        ...districts.flatMap(d => [d.worldBounds.minX, d.worldBounds.maxX]),
+    ];
+    const allZ = [
+        ...buildings.map(b => b.position.z),
+        ...districts.flatMap(d => [d.worldBounds.minZ, d.worldBounds.maxZ]),
+    ];
+    return {
+        minX: Math.min(...allX),
+        maxX: Math.max(...allX),
+        minZ: Math.min(...allZ),
+        maxZ: Math.max(...allZ),
+    };
+};
+/**
+ * Filter city data to only include a subdirectory and optionally remap coordinates
+ * to make the subdirectory the new origin (0,0)
+ */
+const filterCityDataForSubdirectory = (cityData, subdirectoryPath, autoCenter = true) => {
+    if (!subdirectoryPath)
+        return cityData;
+    // Normalize path - remove leading/trailing slashes
+    const normalizedPath = subdirectoryPath.replace(/^\/+|\/+$/g, '');
+    // Filter buildings to only those within the subdirectory
+    const filteredBuildings = cityData.buildings.filter(building => building.path === normalizedPath ||
+        building.path.startsWith(normalizedPath + '/') ||
+        building.path.startsWith(`/${normalizedPath}`));
+    // Filter districts to only those within the subdirectory
+    const filteredDistricts = cityData.districts.filter(district => district.path === normalizedPath ||
+        district.path.startsWith(normalizedPath + '/') ||
+        district.path.startsWith(`/${normalizedPath}`));
+    // Find the subdirectory district to get its bounds
+    const subdirectoryDistrict = cityData.districts.find(d => d.path === normalizedPath);
+    if (!subdirectoryDistrict && filteredBuildings.length === 0) {
+        // Subdirectory not found or empty
+        return {
+            ...cityData,
+            buildings: [],
+            districts: [],
+            bounds: { minX: 0, maxX: 100, minZ: 0, maxZ: 100 },
+            metadata: {
+                ...cityData.metadata,
+                rootPath: normalizedPath,
+            },
+        };
+    }
+    // Calculate the bounds of the subdirectory content
+    const contentBounds = recalculateBounds(filteredBuildings, filteredDistricts);
+    let remappedBuildings;
+    let remappedDistricts;
+    let newBounds;
+    if (autoCenter) {
+        // Calculate offset to make subdirectory origin (0,0)
+        const offsetX = -contentBounds.minX;
+        const offsetZ = -contentBounds.minZ;
+        // Remap building coordinates relative to subdirectory origin
+        remappedBuildings = filteredBuildings.map(building => ({
+            ...building,
+            position: {
+                ...building.position,
+                x: building.position.x + offsetX,
+                z: building.position.z + offsetZ,
+            },
+            // Make path relative to subdirectory
+            path: building.path === normalizedPath
+                ? building.path.split('/').pop() || building.path
+                : building.path.substring(normalizedPath.length + 1),
+        }));
+        // Remap district coordinates relative to subdirectory origin
+        remappedDistricts = filteredDistricts.map(district => ({
+            ...district,
+            worldBounds: {
+                minX: district.worldBounds.minX + offsetX,
+                maxX: district.worldBounds.maxX + offsetX,
+                minZ: district.worldBounds.minZ + offsetZ,
+                maxZ: district.worldBounds.maxZ + offsetZ,
+            },
+            // Make path relative to subdirectory
+            path: district.path === normalizedPath
+                ? '' // The subdirectory itself becomes the root
+                : district.path.substring(normalizedPath.length + 1),
+        }));
+        // New bounds with origin at (0,0)
+        newBounds = {
+            minX: 0,
+            maxX: contentBounds.maxX - contentBounds.minX,
+            minZ: 0,
+            maxZ: contentBounds.maxZ - contentBounds.minZ,
+        };
+    }
+    else {
+        // Preserve original coordinates when autoCenter is disabled
+        remappedBuildings = filteredBuildings.map(building => ({
+            ...building,
+            // Make path relative to subdirectory
+            path: building.path === normalizedPath
+                ? building.path.split('/').pop() || building.path
+                : building.path.substring(normalizedPath.length + 1),
+        }));
+        remappedDistricts = filteredDistricts.map(district => ({
+            ...district,
+            // Make path relative to subdirectory
+            path: district.path === normalizedPath
+                ? '' // The subdirectory itself becomes the root
+                : district.path.substring(normalizedPath.length + 1),
+        }));
+        // Preserve original full city bounds to maintain spatial context
+        newBounds = cityData.bounds;
+    }
+    return {
+        ...cityData,
+        buildings: remappedBuildings,
+        districts: remappedDistricts,
+        bounds: newBounds,
+        metadata: {
+            ...cityData.metadata,
+            rootPath: normalizedPath,
+            totalFiles: filteredBuildings.length,
+            totalDirectories: filteredDistricts.length,
+        },
+    };
+};
+exports.filterCityDataForSubdirectory = filterCityDataForSubdirectory;
+/**
+ * Filter city data based on multiple directory filters with include/exclude modes
+ */
+const filterCityDataForMultipleDirectories = (cityData, filters, autoCenter = true, combineMode = 'union') => {
+    if (!filters || filters.length === 0)
+        return cityData;
+    // Normalize all filter paths
+    const normalizedFilters = filters.map(filter => ({
+        ...filter,
+        path: filter.path.replace(/^\/+|\/+$/g, ''),
+    }));
+    const includeFilters = normalizedFilters.filter(f => f.mode === 'include');
+    const excludeFilters = normalizedFilters.filter(f => f.mode === 'exclude');
+    // Helper function to check if a path matches a filter
+    const matchesFilter = (itemPath, filterPath) => {
+        const normalizedItemPath = itemPath.replace(/^\/+/, '');
+        return normalizedItemPath === filterPath || normalizedItemPath.startsWith(filterPath + '/');
+    };
+    // Filter buildings based on include/exclude rules
+    const filteredBuildings = cityData.buildings.filter(building => {
+        // Check excludes first (they take precedence)
+        for (const filter of excludeFilters) {
+            if (matchesFilter(building.path, filter.path)) {
+                return false;
+            }
+        }
+        // If we have includes, must match based on combine mode
+        if (includeFilters.length > 0) {
+            if (combineMode === 'union') {
+                // Union: match any include filter
+                return includeFilters.some(filter => matchesFilter(building.path, filter.path));
+            }
+            else {
+                // Intersection: must match all include filters (rare use case)
+                return includeFilters.every(filter => matchesFilter(building.path, filter.path));
+            }
+        }
+        // No includes means include everything (except excludes)
+        return true;
+    });
+    // Filter districts with the same logic
+    const filteredDistricts = cityData.districts.filter(district => {
+        // Check excludes first
+        for (const filter of excludeFilters) {
+            if (matchesFilter(district.path, filter.path)) {
+                return false;
+            }
+        }
+        // Check if district contains any included content
+        if (includeFilters.length > 0) {
+            if (combineMode === 'union') {
+                // Include district if it matches any filter or contains matching content
+                return includeFilters.some(filter => matchesFilter(district.path, filter.path) || matchesFilter(filter.path, district.path));
+            }
+            else {
+                // Intersection mode for districts is complex - simplify to union behavior
+                return includeFilters.some(filter => matchesFilter(district.path, filter.path) || matchesFilter(filter.path, district.path));
+            }
+        }
+        return true;
+    });
+    // If nothing matches, return empty city
+    if (filteredBuildings.length === 0 && filteredDistricts.length === 0) {
+        return {
+            ...cityData,
+            buildings: [],
+            districts: [],
+            bounds: { minX: 0, maxX: 100, minZ: 0, maxZ: 100 },
+            metadata: {
+                ...cityData.metadata,
+                rootPath: filters.map(f => `${f.mode}:${f.path}`).join(', '),
+            },
+        };
+    }
+    // Calculate bounds and optionally recenter
+    const contentBounds = recalculateBounds(filteredBuildings, filteredDistricts);
+    if (autoCenter) {
+        // Calculate offset to center the content
+        const offsetX = -contentBounds.minX;
+        const offsetZ = -contentBounds.minZ;
+        // Remap coordinates
+        const remappedBuildings = filteredBuildings.map(building => ({
+            ...building,
+            position: {
+                ...building.position,
+                x: building.position.x + offsetX,
+                z: building.position.z + offsetZ,
+            },
+        }));
+        const remappedDistricts = filteredDistricts.map(district => ({
+            ...district,
+            worldBounds: {
+                minX: district.worldBounds.minX + offsetX,
+                maxX: district.worldBounds.maxX + offsetX,
+                minZ: district.worldBounds.minZ + offsetZ,
+                maxZ: district.worldBounds.maxZ + offsetZ,
+            },
+        }));
+        return {
+            ...cityData,
+            buildings: remappedBuildings,
+            districts: remappedDistricts,
+            bounds: {
+                minX: 0,
+                maxX: contentBounds.maxX - contentBounds.minX,
+                minZ: 0,
+                maxZ: contentBounds.maxZ - contentBounds.minZ,
+            },
+            metadata: {
+                ...cityData.metadata,
+                rootPath: filters.map(f => `${f.mode}:${f.path}`).join(', '),
+                totalFiles: remappedBuildings.length,
+                totalDirectories: remappedDistricts.length,
+            },
+        };
+    }
+    else {
+        // Return filtered data with original coordinates and bounds
+        return {
+            ...cityData,
+            buildings: filteredBuildings,
+            districts: filteredDistricts,
+            bounds: cityData.bounds, // Preserve original bounds when autoCenter is false
+            metadata: {
+                ...cityData.metadata,
+                rootPath: filters.map(f => `${f.mode}:${f.path}`).join(', '),
+                totalFiles: filteredBuildings.length,
+                totalDirectories: filteredDistricts.length,
+            },
+        };
+    }
+};
+exports.filterCityDataForMultipleDirectories = filterCityDataForMultipleDirectories;

package/dist/components/ArchitectureMapHighlightLayers.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import { HighlightLayer } from '../render/client/drawLayeredBuildings';
+import { CityData, CityBuilding, CityDistrict, SelectiveRenderOptions } from '@principal-ai/file-city-builder';
+export interface ArchitectureMapHighlightLayersProps {
+    cityData?: CityData;
+    highlightLayers?: HighlightLayer[];
+    onLayerToggle?: (layerId: string, enabled: boolean) => void;
+    showLayerControls?: boolean;
+    defaultBuildingColor?: string;
+    focusDirectory?: string | null;
+    rootDirectoryName?: string;
+    onDirectorySelect?: (directory: string | null) => void;
+    onFileClick?: (path: string, type: 'file' | 'directory') => void;
+    enableZoom?: boolean;
+    fullSize?: boolean;
+    showGrid?: boolean;
+    showFileNames?: boolean;
+    className?: string;
+    selectiveRender?: SelectiveRenderOptions;
+    canvasBackgroundColor?: string;
+    hoverBorderColor?: string;
+    disableOpacityDimming?: boolean;
+    defaultDirectoryColor?: string;
+    subdirectoryMode?: {
+        enabled?: boolean;
+        rootPath?: string;
+        autoCenter?: boolean;
+        filters?: Array<{
+            path: string;
+            mode: 'include' | 'exclude';
+        }>;
+        combineMode?: 'union' | 'intersection';
+    } | null;
+    showFileTypeIcons?: boolean;
+    showDirectoryLabels?: boolean;
+    transform?: {
+        rotation?: 0 | 90 | 180 | 270;
+        flipHorizontal?: boolean;
+        flipVertical?: boolean;
+    };
+    onHover?: (info: {
+        hoveredDistrict: CityDistrict | null;
+        hoveredBuilding: CityBuilding | null;
+        mousePos: {
+            x: number;
+            y: number;
+        };
+        fileTooltip: {
+            text: string;
+        } | null;
+        directoryTooltip: {
+            text: string;
+        } | null;
+        fileCount: number | null;
+    }) => void;
+    buildingBorderRadius?: number;
+    districtBorderRadius?: number;
+}
+declare function ArchitectureMapHighlightLayersInner({ cityData, highlightLayers, onLayerToggle, focusDirectory, rootDirectoryName, onDirectorySelect, onFileClick, enableZoom, fullSize, showGrid, showFileNames, className, selectiveRender, canvasBackgroundColor, hoverBorderColor, disableOpacityDimming, defaultDirectoryColor, defaultBuildingColor, subdirectoryMode, showLayerControls, showFileTypeIcons, showDirectoryLabels, transform, // Default to no rotation
+onHover, buildingBorderRadius, districtBorderRadius, }: ArchitectureMapHighlightLayersProps): React.JSX.Element;
+export declare const ArchitectureMapHighlightLayers: typeof ArchitectureMapHighlightLayersInner;
+export {};
+//# sourceMappingURL=ArchitectureMapHighlightLayers.d.ts.map

package/dist/components/ArchitectureMapHighlightLayers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchitectureMapHighlightLayers.d.ts","sourceRoot":"","sources":["../../src/components/ArchitectureMapHighlightLayers.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4D,MAAM,OAAO,CAAC;AAQjF,OAAO,EAIL,cAAc,EAEf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AAWzC,MAAM,WAAW,mCAAmC;IAElD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAGpB,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5D,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAG9B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,KAAK,IAAI,CAAC;IACjE,UAAU,CAAC,EAAE,OAAO,CAAC;IAGrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,sBAAsB,CAAC;IAGzC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAG/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAG/B,gBAAgB,CAAC,EAAE;QACjB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,OAAO,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAA;SAAE,CAAC,CAAC;QAC/D,WAAW,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC;KACxC,GAAG,IAAI,CAAC;IAGT,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAG9B,SAAS,CAAC,EAAE;QACV,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,CAAC;IAEF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QACf,eAAe,EAAE,YAAY,GAAG,IAAI,CAAC;QACrC,eAAe,EAAE,YAAY,GAAG,IAAI,CAAC;QACrC,QAAQ,EAAE;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACnC,WAAW,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QACrC,gBAAgB,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QAC1C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;KAC1B,KAAK,IAAI,CAAC;IAGX,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AA6GD,iBAAS,mCAAmC,CAAC,EAC3C,QAAQ,EACR,eAAoB,EACpB,aAAa,EACb,cAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,UAAkB,EAClB,QAAgB,EAChB,QAAgB,EAChB,aAAqB,EACrB,SAAc,EACd,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,qBAA4B,EAC5B,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,iBAAyB,EACzB,iBAAwB,EACxB,mBAA0B,EAC1B,SAA2B,EAAE,yBAAyB;AACtD,OAAO,EACP,oBAAwB,EACxB,oBAAwB,GACzB,EAAE,mCAAmC,qBA0uCrC;AA0BD,eAAO,MAAM,8BAA8B,4CAAsC,CAAC"}