@nice2dev/spatial-core 1.0.10

package/dist/import/index.js

@@ -0,0 +1,1092 @@
+/**
+ * Import — Import external formats into FloorPlanDocument.
+ *
+ * Supported formats:
+ * - DXF (AutoCAD Drawing Exchange Format)
+ * - SVG (Scalable Vector Graphics)
+ * - GeoJSON (Geographic JSON)
+ * - IFC (Industry Foundation Classes) — basic support
+ *
+ * @module @nice2dev/spatial-core/import
+ */
+/** Parse DXF content string. */
+function parseDXF(content) {
+    const entities = [];
+    const lines = content.split(/\r?\n/);
+    let i = 0;
+    let inEntities = false;
+    let currentEntity = null;
+    let vertices = [];
+    let currentX = null;
+    while (i < lines.length) {
+        const code = parseInt(lines[i]?.trim() ?? '', 10);
+        const value = lines[i + 1]?.trim() ?? '';
+        i += 2;
+        // Start of ENTITIES section
+        if (code === 2 && value === 'ENTITIES') {
+            inEntities = true;
+            continue;
+        }
+        // End of ENTITIES section
+        if (code === 0 && value === 'ENDSEC' && inEntities) {
+            if (currentEntity?.type) {
+                if (vertices.length > 0) {
+                    currentEntity.vertices = [...vertices];
+                }
+                entities.push(currentEntity);
+            }
+            inEntities = false;
+            continue;
+        }
+        if (!inEntities) {
+            continue;
+        }
+        // New entity
+        if (code === 0) {
+            // Save previous entity
+            if (currentEntity?.type) {
+                if (vertices.length > 0) {
+                    currentEntity.vertices = [...vertices];
+                }
+                entities.push(currentEntity);
+            }
+            // Start new entity
+            currentEntity = { type: value, layer: '0' };
+            vertices = [];
+            currentX = null;
+            continue;
+        }
+        if (!currentEntity) {
+            continue;
+        }
+        // Common codes
+        switch (code) {
+            case 8: // Layer
+                currentEntity.layer = value;
+                break;
+            case 5: // Handle
+                currentEntity.handle = value;
+                break;
+            case 10: // X coordinate (start or vertex)
+                currentX = parseFloat(value);
+                break;
+            case 20: // Y coordinate
+                if (currentX !== null) {
+                    vertices.push({ x: currentX, y: parseFloat(value) });
+                    if (!currentEntity.position) {
+                        currentEntity.position = { x: currentX, y: parseFloat(value) };
+                    }
+                    currentX = null;
+                }
+                break;
+            case 11: // X2 (end point for LINE)
+                currentX = parseFloat(value);
+                break;
+            case 21: // Y2
+                if (currentX !== null) {
+                    vertices.push({ x: currentX, y: parseFloat(value) });
+                    currentX = null;
+                }
+                break;
+            case 40: // Radius (CIRCLE) or text height
+                if (currentEntity.type === 'CIRCLE' || currentEntity.type === 'ARC') {
+                    currentEntity.radius = parseFloat(value);
+                }
+                break;
+            case 50: // Start angle (ARC)
+                currentEntity.startAngle = parseFloat(value);
+                break;
+            case 51: // End angle (ARC)
+                currentEntity.endAngle = parseFloat(value);
+                break;
+            case 1: // Text content
+                currentEntity.text = value;
+                break;
+            case 2: // Block name (INSERT)
+                currentEntity.blockName = value;
+                break;
+            case 70: // Flags (polyline closed flag)
+                if (parseInt(value, 10) & 1) {
+                    currentEntity.closed = true;
+                }
+                break;
+        }
+    }
+    return entities;
+}
+/**
+ * Import DXF file content.
+ */
+export function importDXF(content, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const errors = [];
+    const scaleFactor = options.scaleFactor ?? 1;
+    const originOffset = options.originOffset ?? { x: 0, y: 0 };
+    try {
+        const entities = parseDXF(content);
+        const walls = [];
+        const zones = [];
+        const objects = [];
+        const layersFound = new Set();
+        let entitiesSkipped = 0;
+        for (const entity of entities) {
+            layersFound.add(entity.layer);
+            // Check layer filters
+            if (options.includeLayers && !options.includeLayers.includes(entity.layer)) {
+                entitiesSkipped++;
+                continue;
+            }
+            if (options.excludeLayers?.includes(entity.layer)) {
+                entitiesSkipped++;
+                continue;
+            }
+            // Map layer name
+            const layerName = options.layerMappings?.[entity.layer] ?? entity.layer;
+            switch (entity.type) {
+                case 'LINE':
+                    if (entity.vertices && entity.vertices.length >= 2) {
+                        const start = applyTransform(entity.vertices[0], scaleFactor, originOffset);
+                        const end = applyTransform(entity.vertices[1], scaleFactor, originOffset);
+                        walls.push({ start, end, layer: layerName });
+                    }
+                    break;
+                case 'LWPOLYLINE':
+                case 'POLYLINE':
+                    if (entity.vertices && entity.vertices.length >= 2) {
+                        const transformedVertices = entity.vertices.map((v) => applyTransform(v, scaleFactor, originOffset));
+                        // Check if closed polyline should be a zone
+                        if (entity.closed && options.convertClosedPolylinesToZones) {
+                            const area = calculatePolygonArea(transformedVertices);
+                            const minArea = options.minZoneArea ?? 0.1;
+                            if (area >= minArea) {
+                                zones.push({
+                                    name: layerName,
+                                    boundary: transformedVertices,
+                                    layer: layerName,
+                                });
+                                continue;
+                            }
+                        }
+                        // Convert to walls
+                        const count = entity.closed
+                            ? transformedVertices.length
+                            : transformedVertices.length - 1;
+                        for (let j = 0; j < count; j++) {
+                            const start = transformedVertices[j];
+                            const end = transformedVertices[(j + 1) % transformedVertices.length];
+                            walls.push({ start, end, layer: layerName });
+                        }
+                    }
+                    break;
+                case 'CIRCLE':
+                    if (entity.position && entity.radius) {
+                        const center = applyTransform(entity.position, scaleFactor, originOffset);
+                        objects.push({
+                            type: 'circle',
+                            position: center,
+                            layer: layerName,
+                            metadata: { radius: entity.radius * scaleFactor },
+                        });
+                    }
+                    break;
+                case 'INSERT':
+                    if (entity.position && entity.blockName) {
+                        const pos = applyTransform(entity.position, scaleFactor, originOffset);
+                        objects.push({
+                            type: 'block-reference',
+                            position: pos,
+                            layer: layerName,
+                            metadata: { blockName: entity.blockName },
+                        });
+                    }
+                    break;
+                default:
+                    entitiesSkipped++;
+                    warnings.push({
+                        code: 'UNSUPPORTED_ENTITY',
+                        message: `Unsupported DXF entity type: ${entity.type}`,
+                        context: { type: entity.type, layer: entity.layer },
+                    });
+            }
+        }
+        // Assemble document
+        const document = assembleDocument(walls, zones, objects, layersFound, {
+            name: 'Imported DXF',
+            sourceFormat: 'dxf',
+            units: options.defaultUnits ?? 'metric',
+        });
+        return {
+            success: true,
+            document,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: walls.length,
+                zonesImported: zones.length,
+                objectsImported: objects.length,
+                layersFound: layersFound.size,
+                entitiesSkipped,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+    catch (err) {
+        errors.push({
+            code: 'PARSE_ERROR',
+            message: err instanceof Error ? err.message : 'Unknown error parsing DXF',
+            fatal: true,
+        });
+        return {
+            success: false,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: 0,
+                zonesImported: 0,
+                objectsImported: 0,
+                layersFound: 0,
+                entitiesSkipped: 0,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+}
+/* ================================================================
+   SVG IMPORT
+   ================================================================ */
+/** Parse SVG path d attribute to points. */
+function parseSVGPath(d) {
+    const paths = [];
+    let currentPath = [];
+    let currentX = 0;
+    let currentY = 0;
+    let startX = 0;
+    let startY = 0;
+    // Tokenize path
+    const commands = d.match(/[MmLlHhVvCcSsQqTtAaZz]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g) ?? [];
+    let i = 0;
+    while (i < commands.length) {
+        const cmd = commands[i];
+        i++;
+        const getNumber = () => {
+            const val = parseFloat(commands[i] ?? '0');
+            i++;
+            return val;
+        };
+        switch (cmd) {
+            case 'M': // Absolute moveto
+                if (currentPath.length > 0) {
+                    paths.push(currentPath);
+                    currentPath = [];
+                }
+                currentX = getNumber();
+                currentY = getNumber();
+                startX = currentX;
+                startY = currentY;
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'm': // Relative moveto
+                if (currentPath.length > 0) {
+                    paths.push(currentPath);
+                    currentPath = [];
+                }
+                currentX += getNumber();
+                currentY += getNumber();
+                startX = currentX;
+                startY = currentY;
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'L': // Absolute lineto
+                currentX = getNumber();
+                currentY = getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'l': // Relative lineto
+                currentX += getNumber();
+                currentY += getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'H': // Absolute horizontal line
+                currentX = getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'h': // Relative horizontal line
+                currentX += getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'V': // Absolute vertical line
+                currentY = getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'v': // Relative vertical line
+                currentY += getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'Z':
+            case 'z': // Close path
+                if (currentPath.length > 0) {
+                    currentPath.push({ x: startX, y: startY });
+                }
+                currentX = startX;
+                currentY = startY;
+                break;
+            case 'C': // Cubic bezier (absolute) — simplified to endpoint
+                getNumber();
+                getNumber(); // Control point 1
+                getNumber();
+                getNumber(); // Control point 2
+                currentX = getNumber();
+                currentY = getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'c': // Cubic bezier (relative) — simplified to endpoint
+                getNumber();
+                getNumber(); // Control point 1
+                getNumber();
+                getNumber(); // Control point 2
+                currentX += getNumber();
+                currentY += getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'Q': // Quadratic bezier (absolute) — simplified to endpoint
+                getNumber();
+                getNumber(); // Control point
+                currentX = getNumber();
+                currentY = getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+            case 'q': // Quadratic bezier (relative) — simplified to endpoint
+                getNumber();
+                getNumber(); // Control point
+                currentX += getNumber();
+                currentY += getNumber();
+                currentPath.push({ x: currentX, y: currentY });
+                break;
+        }
+    }
+    if (currentPath.length > 0) {
+        paths.push(currentPath);
+    }
+    return paths;
+}
+/** Parse SVG transform attribute. */
+function parseSVGTransform(transform) {
+    let translateX = 0;
+    let translateY = 0;
+    let scale = 1;
+    // Parse translate
+    const translateMatch = transform.match(/translate\s*\(\s*([-\d.]+)(?:\s*,?\s*([-\d.]+))?\s*\)/);
+    if (translateMatch) {
+        translateX = parseFloat(translateMatch[1]);
+        translateY = parseFloat(translateMatch[2] ?? '0');
+    }
+    // Parse scale
+    const scaleMatch = transform.match(/scale\s*\(\s*([-\d.]+)(?:\s*,?\s*([-\d.]+))?\s*\)/);
+    if (scaleMatch) {
+        scale = parseFloat(scaleMatch[1]);
+    }
+    return { translate: { x: translateX, y: translateY }, scale };
+}
+/**
+ * Import SVG file content.
+ */
+export function importSVG(content, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const errors = [];
+    const scaleFactor = options.scaleFactor ?? 1;
+    const originOffset = options.originOffset ?? { x: 0, y: 0 };
+    try {
+        const walls = [];
+        const zones = [];
+        const objects = [];
+        const layersFound = new Set();
+        // Find all path elements
+        const pathRegex = /<path[^>]*\bd="([^"]+)"[^>]*>/gi;
+        let pathMatch;
+        while ((pathMatch = pathRegex.exec(content)) !== null) {
+            const d = pathMatch[1];
+            const fullTag = pathMatch[0];
+            // Get layer/id
+            const idMatch = fullTag.match(/\bid="([^"]+)"/);
+            const layerName = idMatch?.[1] ?? 'default';
+            layersFound.add(layerName);
+            // Get transform
+            const transformMatch = fullTag.match(/\btransform="([^"]+)"/);
+            const transform = transformMatch
+                ? parseSVGTransform(transformMatch[1])
+                : { translate: { x: 0, y: 0 }, scale: 1 };
+            // Parse path
+            const subPaths = parseSVGPath(d);
+            for (const points of subPaths) {
+                if (points.length < 2) {
+                    continue;
+                }
+                const transformedPoints = points.map((p) => applyTransform({
+                    x: p.x * transform.scale + transform.translate.x,
+                    y: p.y * transform.scale + transform.translate.y,
+                }, scaleFactor, originOffset));
+                // Check if closed (becomes zone)
+                const isClosed = Math.abs(transformedPoints[0].x - transformedPoints[transformedPoints.length - 1].x) <
+                    0.1 &&
+                    Math.abs(transformedPoints[0].y - transformedPoints[transformedPoints.length - 1].y) <
+                        0.1;
+                if (isClosed && options.convertClosedPolylinesToZones) {
+                    const area = calculatePolygonArea(transformedPoints);
+                    if (area >= (options.minZoneArea ?? 0.1)) {
+                        zones.push({ name: layerName, boundary: transformedPoints, layer: layerName });
+                        continue;
+                    }
+                }
+                // Convert to walls
+                for (let j = 0; j < transformedPoints.length - 1; j++) {
+                    walls.push({
+                        start: transformedPoints[j],
+                        end: transformedPoints[j + 1],
+                        layer: layerName,
+                    });
+                }
+            }
+        }
+        // Find all line elements
+        const lineRegex = /<line[^>]*\bx1="([^"]+)"[^>]*\by1="([^"]+)"[^>]*\bx2="([^"]+)"[^>]*\by2="([^"]+)"[^>]*>/gi;
+        let lineMatch;
+        while ((lineMatch = lineRegex.exec(content)) !== null) {
+            const x1 = parseFloat(lineMatch[1]);
+            const y1 = parseFloat(lineMatch[2]);
+            const x2 = parseFloat(lineMatch[3]);
+            const y2 = parseFloat(lineMatch[4]);
+            const start = applyTransform({ x: x1, y: y1 }, scaleFactor, originOffset);
+            const end = applyTransform({ x: x2, y: y2 }, scaleFactor, originOffset);
+            walls.push({ start, end, layer: 'default' });
+            layersFound.add('default');
+        }
+        // Find all rect elements
+        const rectRegex = /<rect[^>]*\bx="([^"]+)"[^>]*\by="([^"]+)"[^>]*\bwidth="([^"]+)"[^>]*\bheight="([^"]+)"[^>]*>/gi;
+        let rectMatch;
+        while ((rectMatch = rectRegex.exec(content)) !== null) {
+            const x = parseFloat(rectMatch[1]);
+            const y = parseFloat(rectMatch[2]);
+            const width = parseFloat(rectMatch[3]);
+            const height = parseFloat(rectMatch[4]);
+            const rect = [
+                applyTransform({ x, y }, scaleFactor, originOffset),
+                applyTransform({ x: x + width, y }, scaleFactor, originOffset),
+                applyTransform({ x: x + width, y: y + height }, scaleFactor, originOffset),
+                applyTransform({ x, y: y + height }, scaleFactor, originOffset),
+            ];
+            if (options.convertClosedPolylinesToZones) {
+                zones.push({ name: 'rect', boundary: rect, layer: 'default' });
+            }
+            else {
+                walls.push({ start: rect[0], end: rect[1], layer: 'default' });
+                walls.push({ start: rect[1], end: rect[2], layer: 'default' });
+                walls.push({ start: rect[2], end: rect[3], layer: 'default' });
+                walls.push({ start: rect[3], end: rect[0], layer: 'default' });
+            }
+            layersFound.add('default');
+        }
+        // Find all circle elements
+        const circleRegex = /<circle[^>]*\bcx="([^"]+)"[^>]*\bcy="([^"]+)"[^>]*\br="([^"]+)"[^>]*>/gi;
+        let circleMatch;
+        while ((circleMatch = circleRegex.exec(content)) !== null) {
+            const cx = parseFloat(circleMatch[1]);
+            const cy = parseFloat(circleMatch[2]);
+            const r = parseFloat(circleMatch[3]);
+            const center = applyTransform({ x: cx, y: cy }, scaleFactor, originOffset);
+            objects.push({
+                type: 'circle',
+                position: center,
+                layer: 'default',
+                metadata: { radius: r * scaleFactor },
+            });
+            layersFound.add('default');
+        }
+        // Assemble document
+        const document = assembleDocument(walls, zones, objects, layersFound, {
+            name: 'Imported SVG',
+            sourceFormat: 'svg',
+            units: options.defaultUnits ?? 'metric',
+        });
+        return {
+            success: true,
+            document,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: walls.length,
+                zonesImported: zones.length,
+                objectsImported: objects.length,
+                layersFound: layersFound.size,
+                entitiesSkipped: 0,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+    catch (err) {
+        errors.push({
+            code: 'PARSE_ERROR',
+            message: err instanceof Error ? err.message : 'Unknown error parsing SVG',
+            fatal: true,
+        });
+        return {
+            success: false,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: 0,
+                zonesImported: 0,
+                objectsImported: 0,
+                layersFound: 0,
+                entitiesSkipped: 0,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+}
+/**
+ * Import GeoJSON file content.
+ */
+export function importGeoJSON(content, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const errors = [];
+    const scaleFactor = options.scaleFactor ?? 1;
+    const originOffset = options.originOffset ?? { x: 0, y: 0 };
+    try {
+        const geojson = JSON.parse(content);
+        const walls = [];
+        const zones = [];
+        const objects = [];
+        const layersFound = new Set();
+        let entitiesSkipped = 0;
+        const features = geojson.type === 'FeatureCollection' ? geojson.features : [geojson];
+        for (const feature of features) {
+            const layerName = feature.properties?.layer ?? 'default';
+            layersFound.add(layerName);
+            const geom = feature.geometry;
+            switch (geom.type) {
+                case 'Point': {
+                    const coords = geom.coordinates;
+                    const pos = applyTransform({ x: coords[0], y: coords[1] }, scaleFactor, originOffset);
+                    objects.push({
+                        type: 'marker',
+                        position: pos,
+                        layer: layerName,
+                        metadata: { properties: feature.properties },
+                    });
+                    break;
+                }
+                case 'LineString': {
+                    const coords = geom.coordinates;
+                    for (let i = 0; i < coords.length - 1; i++) {
+                        const start = applyTransform({ x: coords[i][0], y: coords[i][1] }, scaleFactor, originOffset);
+                        const end = applyTransform({ x: coords[i + 1][0], y: coords[i + 1][1] }, scaleFactor, originOffset);
+                        walls.push({ start, end, layer: layerName });
+                    }
+                    break;
+                }
+                case 'MultiLineString': {
+                    const lines = geom.coordinates;
+                    for (const line of lines) {
+                        for (let i = 0; i < line.length - 1; i++) {
+                            const start = applyTransform({ x: line[i][0], y: line[i][1] }, scaleFactor, originOffset);
+                            const end = applyTransform({ x: line[i + 1][0], y: line[i + 1][1] }, scaleFactor, originOffset);
+                            walls.push({ start, end, layer: layerName });
+                        }
+                    }
+                    break;
+                }
+                case 'Polygon': {
+                    const rings = geom.coordinates;
+                    const outerRing = rings[0];
+                    const points = outerRing.map((c) => applyTransform({ x: c[0], y: c[1] }, scaleFactor, originOffset));
+                    zones.push({ name: layerName, boundary: points, layer: layerName });
+                    break;
+                }
+                case 'MultiPolygon': {
+                    const polygons = geom.coordinates;
+                    for (const polygon of polygons) {
+                        const outerRing = polygon[0];
+                        const points = outerRing.map((c) => applyTransform({ x: c[0], y: c[1] }, scaleFactor, originOffset));
+                        zones.push({ name: layerName, boundary: points, layer: layerName });
+                    }
+                    break;
+                }
+                default:
+                    entitiesSkipped++;
+                    warnings.push({
+                        code: 'UNSUPPORTED_GEOMETRY',
+                        message: `Unsupported GeoJSON geometry: ${geom.type}`,
+                    });
+            }
+        }
+        // Assemble document
+        const document = assembleDocument(walls, zones, objects, layersFound, {
+            name: 'Imported GeoJSON',
+            sourceFormat: 'geojson',
+            units: options.defaultUnits ?? 'metric',
+        });
+        return {
+            success: true,
+            document,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: walls.length,
+                zonesImported: zones.length,
+                objectsImported: objects.length,
+                layersFound: layersFound.size,
+                entitiesSkipped,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+    catch (err) {
+        errors.push({
+            code: 'PARSE_ERROR',
+            message: err instanceof Error ? err.message : 'Unknown error parsing GeoJSON',
+            fatal: true,
+        });
+        return {
+            success: false,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: 0,
+                zonesImported: 0,
+                objectsImported: 0,
+                layersFound: 0,
+                entitiesSkipped: 0,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+}
+/* ================================================================
+   IFC IMPORT (Basic)
+   ================================================================ */
+/**
+ * Import IFC file content.
+ * Note: This is a very basic implementation that handles STEP-formatted IFC.
+ * For full IFC support, use a dedicated IFC library like web-ifc.
+ */
+export function importIFC(content, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const errors = [];
+    warnings.push({
+        code: 'LIMITED_IFC_SUPPORT',
+        message: 'IFC import is limited. For full support, use a dedicated IFC library like web-ifc.',
+    });
+    try {
+        const walls = [];
+        const zones = [];
+        const objects = [];
+        const layersFound = new Set();
+        let entitiesSkipped = 0;
+        // Parse IFC entities (very simplified)
+        const lines = content.split(/\r?\n/);
+        const entities = new Map();
+        // First pass: collect all entities
+        for (const line of lines) {
+            const match = line.match(/^#(\d+)\s*=\s*(\w+)\s*\((.+)\)\s*;?$/);
+            if (match) {
+                entities.set(`#${match[1]}`, { type: match[2], params: match[3] });
+            }
+        }
+        // Look for IfcWallStandardCase and IfcSpace
+        for (const [id, entity] of entities) {
+            if (entity.type === 'IFCWALLSTANDARDCASE' || entity.type === 'IFCWALL') {
+                layersFound.add('Walls');
+                const nameMatch = entity.params.match(/'([^']+)'/);
+                const name = nameMatch?.[1] ?? 'Wall';
+                warnings.push({
+                    code: 'IFC_WALL_SIMPLIFIED',
+                    message: `Wall "${name}" (${id}) geometry simplified to placeholder`,
+                });
+                entitiesSkipped++;
+            }
+            else if (entity.type === 'IFCSPACE') {
+                layersFound.add('Spaces');
+                const nameMatch = entity.params.match(/'([^']+)'/);
+                const name = nameMatch?.[1] ?? 'Space';
+                warnings.push({
+                    code: 'IFC_SPACE_SIMPLIFIED',
+                    message: `Space "${name}" (${id}) geometry simplified to placeholder`,
+                });
+                entitiesSkipped++;
+            }
+        }
+        // Assemble document (mostly empty without proper IFC geometry parsing)
+        const document = assembleDocument(walls, zones, objects, layersFound, {
+            name: 'Imported IFC',
+            sourceFormat: 'ifc',
+            units: options.defaultUnits ?? 'metric',
+        });
+        return {
+            success: true,
+            document,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: walls.length,
+                zonesImported: zones.length,
+                objectsImported: objects.length,
+                layersFound: layersFound.size,
+                entitiesSkipped,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+    catch (err) {
+        errors.push({
+            code: 'PARSE_ERROR',
+            message: err instanceof Error ? err.message : 'Unknown error parsing IFC',
+            fatal: true,
+        });
+        return {
+            success: false,
+            warnings,
+            errors,
+            stats: {
+                wallsImported: 0,
+                zonesImported: 0,
+                objectsImported: 0,
+                layersFound: 0,
+                entitiesSkipped: 0,
+                importTimeMs: Date.now() - startTime,
+            },
+        };
+    }
+}
+/* ================================================================
+   UNIFIED IMPORT FUNCTION
+   ================================================================ */
+/**
+ * Import file content in specified format.
+ */
+export function importFile(content, format, options = {}) {
+    switch (format) {
+        case 'dxf':
+            return importDXF(content, options);
+        case 'svg':
+            return importSVG(content, options);
+        case 'geojson':
+            return importGeoJSON(content, options);
+        case 'ifc':
+            return importIFC(content, options);
+        default:
+            return {
+                success: false,
+                warnings: [],
+                errors: [
+                    {
+                        code: 'UNSUPPORTED_FORMAT',
+                        message: `Unsupported import format: ${format}`,
+                        fatal: true,
+                    },
+                ],
+                stats: {
+                    wallsImported: 0,
+                    zonesImported: 0,
+                    objectsImported: 0,
+                    layersFound: 0,
+                    entitiesSkipped: 0,
+                    importTimeMs: 0,
+                },
+            };
+    }
+}
+/**
+ * Detect import format from file extension or content.
+ */
+export function detectFileImportFormat(filename, content) {
+    const ext = filename.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'dxf':
+            return 'dxf';
+        case 'svg':
+            return 'svg';
+        case 'geojson':
+        case 'json':
+            if (content?.includes('"type"') &&
+                (content.includes('"Feature"') || content.includes('"FeatureCollection"'))) {
+                return 'geojson';
+            }
+            return ext === 'geojson' ? 'geojson' : null;
+        case 'ifc':
+            return 'ifc';
+        default:
+            // Try content detection
+            if (content) {
+                if (content.includes('ISO-10303-21') || content.includes('IFCPROJECT')) {
+                    return 'ifc';
+                }
+                if (content.includes('<?xml') && content.includes('<svg')) {
+                    return 'svg';
+                }
+                if (content.includes('SECTION') && content.includes('ENTITIES')) {
+                    return 'dxf';
+                }
+            }
+            return null;
+    }
+}
+/**
+ * Import from file (browser File API).
+ */
+export async function importFromBrowserFile(file, options = {}) {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const content = reader.result;
+            const format = options.format ?? detectFileImportFormat(file.name, content);
+            if (!format) {
+                resolve({
+                    success: false,
+                    warnings: [],
+                    errors: [
+                        {
+                            code: 'UNKNOWN_FORMAT',
+                            message: `Unable to detect format for file: ${file.name}`,
+                            fatal: true,
+                        },
+                    ],
+                    stats: {
+                        wallsImported: 0,
+                        zonesImported: 0,
+                        objectsImported: 0,
+                        layersFound: 0,
+                        entitiesSkipped: 0,
+                        importTimeMs: 0,
+                    },
+                });
+                return;
+            }
+            resolve(importFile(content, format, options));
+        };
+        reader.onerror = () => {
+            resolve({
+                success: false,
+                warnings: [],
+                errors: [
+                    {
+                        code: 'FILE_READ_ERROR',
+                        message: 'Error reading file',
+                        fatal: true,
+                    },
+                ],
+                stats: {
+                    wallsImported: 0,
+                    zonesImported: 0,
+                    objectsImported: 0,
+                    layersFound: 0,
+                    entitiesSkipped: 0,
+                    importTimeMs: 0,
+                },
+            });
+        };
+        reader.readAsText(file);
+    });
+}
+/* ================================================================
+   HELPER FUNCTIONS
+   ================================================================ */
+/** Generate unique ID. */
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/** Apply scale and offset transform. */
+function applyTransform(point, scale, offset) {
+    return {
+        x: point.x * scale + offset.x,
+        y: point.y * scale + offset.y,
+    };
+}
+/** Calculate polygon area using shoelace formula. */
+function calculatePolygonArea(vertices) {
+    let area = 0;
+    const n = vertices.length;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        area += vertices[i].x * vertices[j].y;
+        area -= vertices[j].x * vertices[i].y;
+    }
+    return Math.abs(area / 2);
+}
+/** Calculate bounding box of points. */
+function calculateBounds(points) {
+    if (points.length === 0) {
+        return { x: 0, y: 0, width: 0, height: 0 };
+    }
+    let minX = Infinity, minY = Infinity;
+    let maxX = -Infinity, maxY = -Infinity;
+    for (const p of points) {
+        if (p.x < minX) {
+            minX = p.x;
+        }
+        if (p.y < minY) {
+            minY = p.y;
+        }
+        if (p.x > maxX) {
+            maxX = p.x;
+        }
+        if (p.y > maxY) {
+            maxY = p.y;
+        }
+    }
+    return {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY,
+    };
+}
+/** Get a color for a layer name. */
+function getLayerColor(layerName) {
+    let hash = 0;
+    for (let i = 0; i < layerName.length; i++) {
+        hash = layerName.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    const hue = Math.abs(hash) % 360;
+    return `hsl(${hue}, 60%, 50%)`;
+}
+/** Create transform for position. */
+function createTransform(position) {
+    return {
+        position,
+        rotation: 0,
+        scale: { x: 1, y: 1 },
+    };
+}
+/**
+ * Assemble imported data into a FloorPlanDocument.
+ */
+function assembleDocument(walls, zones, objects, layersFound, docInfo) {
+    const now = new Date().toISOString();
+    const floorId = `floor-${generateId()}`;
+    // Calculate all points for bounds
+    const allPoints = [];
+    for (const w of walls) {
+        allPoints.push(w.start, w.end);
+    }
+    for (const z of zones) {
+        allPoints.push(...z.boundary);
+    }
+    for (const o of objects) {
+        allPoints.push(o.position);
+    }
+    const floorBounds = calculateBounds(allPoints);
+    // Create wall objects
+    const wallObjects = walls.map((w) => ({
+        id: `wall-${generateId()}`,
+        type: 'wall',
+        category: 'building',
+        name: 'Wall',
+        transform: createTransform(w.start),
+        bounds: calculateBounds([w.start, w.end]),
+        layer: w.layer,
+        locked: false,
+        visible: true,
+        metadata: {
+            end: w.end,
+            thickness: w.thickness ?? 0.15,
+            importedAt: now,
+        },
+        childIds: [],
+    }));
+    // Create general objects
+    const generalObjects = objects.map((o) => ({
+        id: `obj-${generateId()}`,
+        type: o.type,
+        category: 'annotation',
+        name: o.type,
+        transform: createTransform(o.position),
+        bounds: {
+            x: o.position.x - 10,
+            y: o.position.y - 10,
+            width: 20,
+            height: 20,
+        },
+        layer: o.layer,
+        locked: false,
+        visible: true,
+        metadata: {
+            ...o.metadata,
+            importedAt: now,
+        },
+        childIds: [],
+    }));
+    // Create layers
+    const layers = Array.from(layersFound).map((name) => ({
+        id: `layer-${generateId()}`,
+        name,
+        type: (name.toLowerCase().includes('wall') ? 'walls' : 'custom'),
+        visible: true,
+        locked: false,
+        opacity: 1,
+        color: getLayerColor(name),
+        objects: [
+            ...wallObjects.filter((w) => w.layer === name),
+            ...generalObjects.filter((o) => o.layer === name),
+        ],
+    }));
+    // Create floor
+    const floor = {
+        id: floorId,
+        name: 'Imported Floor',
+        level: 0,
+        elevation: 0,
+        ceilingHeight: 2.7,
+        bounds: floorBounds,
+        layers,
+    };
+    // Create zones - stored in document metadata for future use
+    // TODO: Add zones property to FloorPlanDocument when supported
+    const documentZones = zones.map((z) => ({
+        id: `zone-${generateId()}`,
+        name: z.name,
+        type: 'custom',
+        boundary: z.boundary,
+        floorId,
+        roomIds: [],
+        color: getLayerColor(z.name),
+    }));
+    // Create document
+    const document = {
+        $schema: 'https://nice2dev.com/schemas/nsp-v1.json',
+        version: '1.0.0',
+        type: 'floor-plan',
+        metadata: {
+            id: `doc-${generateId()}`,
+            name: docInfo.name,
+            description: `Imported from ${docInfo.sourceFormat.toUpperCase()}`,
+            created: now,
+            modified: now,
+            tags: ['imported', docInfo.sourceFormat],
+        },
+        floors: [floor],
+        settings: {
+            units: docInfo.units,
+            scale: 50,
+            grid: {
+                visible: true,
+                size: 0.5,
+                snapEnabled: true,
+            },
+            defaultWallHeight: 2.7,
+            defaultWallThickness: 0.15,
+            precision: 2,
+        },
+    };
+    // Attach zones to metadata for later use
+    document.zones = documentZones;
+    return document;
+}
+/* ================================================================
+   WEB WORKER IMPORT (re-exported)
+   ================================================================ */
+export { importFileInWorker, importFileAsync, isWorkerSupported, terminateImportWorker, createImportWorker, } from './workerImport';
+//# sourceMappingURL=index.js.map