@pascal-app/core 1.0.3 → 1.0.5

package/dist/commands/structure/divide-zone.js

@@ -0,0 +1,186 @@
+import { area, containsPoint, difference, union } from '../../lib/polygon-boolean.js';
+import { segmentsIntersect } from '../../lib/polygon-relations.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveFrameAt } from '../../systems/wall/wall-curve.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../../systems/wall/wall-footprint.js';
+import { at, boundaries, project, requireZone, roomFace, } from './shared.js';
+export function createZoneDivisionContext(nodes, zoneId) {
+    const zone = requireZone(nodes, zoneId);
+    const boundaryNodes = boundaries(nodes, zone.parentId);
+    const faces = extractRooms(boundaryNodes);
+    return { zoneId, boundaryNodes, face: roomFace(nodes, zone, faces), roomCount: faces.length };
+}
+export function snapZoneBoundary(nodes, zoneId, point, gridStep = 0, context = createZoneDivisionContext(nodes, zoneId), 
+// Set when the pointer landed on a boundary's own surface. The cut belongs on
+// that boundary however thick it is, so the proximity cap — which only exists
+// to reject pointers floating in the middle of the room — does not apply.
+boundaryId) {
+    const face = context.face;
+    if (!point.every(Number.isFinite))
+        throw Error('Invalid cut coordinates.');
+    if (!face)
+        throw Error('The room must be enclosed.');
+    const named = boundaryId ? face.spans.filter((span) => span.boundaryId === boundaryId) : [];
+    const candidates = (named.length ? named : face.spans).flatMap((span) => {
+        const node = nodes[span.boundaryId];
+        if (node?.type !== 'wall' && node?.type !== 'separator')
+            return [];
+        const pointAt = (t) => {
+            if (node.type === 'separator')
+                return at(node.start, node.end, t);
+            const { point: p } = getWallCurveFrameAt(node, t);
+            return [p.x, p.y];
+        };
+        const samples = node.type === 'wall' && node.curveOffset ? 64 : 1;
+        return Array.from({ length: samples }, (_, i) => {
+            const a = pointAt(span.t0 + ((span.t1 - span.t0) * i) / samples);
+            const b = pointAt(span.t0 + ((span.t1 - span.t0) * (i + 1)) / samples);
+            const projected = project(point, a, b);
+            const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            const t = gridStep > 0 && samples === 1
+                ? Math.max(0, Math.min(1, (Math.round((projected.t * length) / gridStep) * gridStep) / length))
+                : projected.t;
+            return {
+                ...projected,
+                point: at(a, b, t),
+                boundaryId: node.id,
+                direction: [(b[0] - a[0]) / length, (b[1] - a[1]) / length],
+            };
+        });
+    });
+    const nearest = candidates.sort((a, b) => a.distance - b.distance || a.boundaryId.localeCompare(b.boundaryId))[0];
+    if (!nearest || !Number.isFinite(nearest.distance))
+        return null;
+    if (!named.length && nearest.distance > 1)
+        return null;
+    const distance = Math.hypot(nearest.point[0] - point[0], nearest.point[1] - point[1]);
+    return named.length || distance <= 1 ? { ...nearest, distance } : null;
+}
+function overlapsSegment(a, b, c, d) {
+    const dx = b[0] - a[0], dz = b[1] - a[1];
+    const length = Math.hypot(dx, dz);
+    if ([c, d].some((p) => Math.abs((p[0] - a[0]) * dz - (p[1] - a[1]) * dx) > 1e-8 * length))
+        return false;
+    const station = (p) => ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / length;
+    const t0 = station(c), t1 = station(d);
+    return Math.min(length, Math.max(t0, t1)) - Math.max(0, Math.min(t0, t1)) > 1e-8;
+}
+function segmentDistance(a, b, c, d) {
+    if (segmentsIntersect(a, b, c, d))
+        return 0;
+    return Math.min(project(a, c, d).distance, project(b, c, d).distance, project(c, a, b).distance, project(d, a, b).distance);
+}
+export function divideZone(nodes, input, context = createZoneDivisionContext(nodes, input.zoneId)) {
+    const zone = requireZone(nodes, input.zoneId);
+    const reject = (code, message) => ({
+        changes: [],
+        separatorIds: [],
+        conflicts: [{ code, nodeIds: [zone.id], message }],
+    });
+    const source = input.path ?? input.cut;
+    const closed = input.closed ?? false;
+    if ((input.path && input.cut) || !source || source.length < (closed ? 3 : 2))
+        return reject('invalid-path', 'Supply one path with at least two points, or three for an island.');
+    if (source.some((p) => p.length !== 2 || !p.every(Number.isFinite)))
+        throw Error('Invalid cut coordinates.');
+    const face = context.face;
+    if (!face)
+        return reject('open-room', 'The room must be enclosed.');
+    const rings = [face.referencePolygon, ...face.holes].map((ring) => [...ring]);
+    const points = source.map(([x, z]) => [x, z]);
+    if (!closed) {
+        const first = snapZoneBoundary(nodes, zone.id, points[0], 0, context, input.startBoundaryId);
+        const last = snapZoneBoundary(nodes, zone.id, points.at(-1), 0, context, input.endBoundaryId);
+        if (!first || !last)
+            return reject('snap-distance', 'Move within 1 m of a room boundary.');
+        points[0] = first.point;
+        points[points.length - 1] = last.point;
+        // The graph's adaptive curve samples are coarser than endpoint snapping.
+        // Include the snapped station so its tiny chord deviation is not an exit.
+        for (const snapped of [first, last]) {
+            const boundary = nodes[snapped.boundaryId];
+            if (boundary?.type !== 'wall' || !boundary.curveOffset)
+                continue;
+            const closest = rings
+                .flatMap((ring) => ring.map((a, i) => ({
+                ring,
+                i,
+                ...project(snapped.point, a, ring[(i + 1) % ring.length]),
+            })))
+                .sort((a, b) => a.distance - b.distance)[0];
+            if (closest && closest.t > 1e-8 && closest.t < 1 - 1e-8)
+                closest.ring.splice(closest.i + 1, 0, snapped.point);
+        }
+    }
+    const segments = points
+        .slice(0, closed ? points.length : -1)
+        .map((start, i) => [start, points[(i + 1) % points.length]]);
+    if (segments.some(([a, b]) => Math.hypot(b[0] - a[0], b[1] - a[1]) < 0.05 - 1e-9))
+        return reject('short-cut', 'Each segment must be at least 5 cm long.');
+    for (let i = 0; i < segments.length; i++) {
+        const [a, b] = segments[i];
+        for (let j = i + 1; j < segments.length; j++) {
+            const [c, d] = segments[j];
+            const adjacent = j === i + 1 || (closed && i === 0 && j === segments.length - 1);
+            if (overlapsSegment(a, b, c, d) || (!adjacent && segmentsIntersect(a, b, c, d)))
+                return reject('self-intersection', 'The path must not cross or retrace itself.');
+        }
+    }
+    if (closed && area([{ outer: points, holes: [] }]) < 0.25 - 1e-9)
+        return reject('small-island', 'An island must cover at least 0.25 m².');
+    const footprint = { outer: rings[0], holes: rings.slice(1) };
+    const boundarySegments = [footprint.outer, ...footprint.holes].flatMap((ring) => ring.map((a, i) => [a, ring[(i + 1) % ring.length]]));
+    for (const [index, [start, end]] of segments.entries()) {
+        if (boundarySegments.some(([a, b]) => overlapsSegment(start, end, a, b)))
+            return reject('boundary-overlap', 'The path must not run along an existing boundary.');
+        for (const [a, b] of boundarySegments) {
+            if (!segmentsIntersect(start, end, a, b))
+                continue;
+            const dx = end[0] - start[0], dz = end[1] - start[1];
+            const sx = b[0] - a[0], sz = b[1] - a[1];
+            const denominator = dx * sz - dz * sx;
+            const t = Math.abs(denominator) > 1e-9
+                ? ((a[0] - start[0]) * sz - (a[1] - start[1]) * sx) / denominator
+                : project(a, start, end).t;
+            const endpoint = !closed &&
+                ((index === 0 && Math.abs(t) < 1e-6) ||
+                    (index === segments.length - 1 && Math.abs(t - 1) < 1e-6));
+            if (!endpoint)
+                return reject('outside-room', 'Only the ends of an open path may touch the room boundary.');
+        }
+        if (!containsPoint([footprint], at(start, end, 0.5)))
+            return reject('outside-room', 'The entire path must stay inside the room, outside its holes.');
+    }
+    if (closed) {
+        const walls = context.boundaryNodes.filter((node) => node.type === 'wall');
+        const miters = calculateLevelMiters(walls);
+        const wallPolygons = walls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]));
+        const clear = difference(footprint, union(wallPolygons));
+        if (area(difference(points, clear)) > 1e-8)
+            return reject('outside-room', 'The island must fit entirely inside the clear room polygon.');
+        const wallSegments = wallPolygons.flatMap((ring) => ring.map((a, i) => [a, ring[(i + 1) % ring.length]]));
+        if (segments.some(([a, b]) => wallSegments.some(([c, d]) => segmentDistance(a, b, c, d) < 0.05 - 1e-8)))
+            return reject('wall-clearance', 'Keep the island at least 5 cm from wall faces.');
+    }
+    const ids = new Set();
+    const separators = segments.map(([start, end]) => {
+        const separator = SeparatorNode.parse({
+            id: input.mintId('separator'),
+            parentId: zone.parentId,
+            start,
+            end,
+        });
+        if (nodes[separator.id] || ids.has(separator.id))
+            throw Error(`Duplicate separator id: ${separator.id}`);
+        ids.add(separator.id);
+        return separator;
+    });
+    if (extractRooms([...context.boundaryNodes, ...separators]).length !== context.roomCount + 1)
+        return reject('invalid-cut', 'The path must divide this room into exactly two rooms.');
+    return {
+        changes: separators.map((node) => ({ op: 'create', node })),
+        separatorIds: separators.map((node) => node.id),
+        separatorId: separators[0].id,
+    };
+}

package/dist/commands/structure/duplicate-zone.d.ts

@@ -0,0 +1,7 @@
+import { type Point, type StructureNodes } from './shared.js';
+import { type TransformZoneInput } from './transform-zone.js';
+export type DuplicateZoneInput = Omit<TransformZoneInput, 'translate'> & {
+    translate: Point;
+};
+export declare function duplicateZone(nodes: StructureNodes, input: DuplicateZoneInput): import("./transform-zone.js").ZoneTransformPlan;
+//# sourceMappingURL=duplicate-zone.d.ts.map

package/dist/commands/structure/duplicate-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/duplicate-zone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAe,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AACvE,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE7E,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,CAAA;AAE7F,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,gDAkB7E"}

package/dist/commands/structure/duplicate-zone.js

@@ -0,0 +1,21 @@
+import { requireZone } from './shared.js';
+import { planZoneTransform } from './transform-zone.js';
+export function duplicateZone(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    const first = planZoneTransform(nodes, input, true);
+    if (zone.floor?.support !== 'open' || !first.conflicts?.length)
+        return first;
+    const xs = zone.polygon.map(([x]) => x), zs = zone.polygon.map(([, z]) => z);
+    const width = Math.max(...xs) - Math.min(...xs), depth = Math.max(...zs) - Math.min(...zs);
+    for (const translate of [
+        [width, 0],
+        [0, depth],
+        [-width, 0],
+        [0, -depth],
+    ]) {
+        const plan = planZoneTransform(nodes, { ...input, translate }, true);
+        if (!plan.conflicts?.length)
+            return plan;
+    }
+    return first;
+}

package/dist/commands/structure/floor-opening.d.ts

@@ -0,0 +1,36 @@
+import { type Ring } from '../../lib/polygon-boolean.js';
+import { FloorOpeningNode } from '../../schema/index.js';
+import type { StructureNodes, StructurePlan } from './shared.js';
+export type CutFloorOpeningInput = {
+    levelId?: string;
+    zoneId?: string;
+    levelIds?: string[];
+    polygon?: Ring;
+    rect?: {
+        x: number;
+        z: number;
+        width: number;
+        depth: number;
+    };
+    drawnOn?: 'floor' | 'ceiling';
+    cutsPrimary?: boolean;
+    cutsAdjacent?: boolean;
+    source?: string;
+    ownerId?: string;
+    mintId: (kind: 'floor-opening') => string;
+};
+export type FloorOpeningHint = {
+    code: 'manual-ceiling';
+    openingId: string;
+    surfaceIds: string[];
+    message: string;
+};
+export declare function floorOpeningHints(nodes: StructureNodes, opening: FloorOpeningNode): FloorOpeningHint[];
+export declare function cutFloorOpening(nodes: StructureNodes, input: CutFloorOpeningInput): StructurePlan & {
+    openingIds: string[];
+    hints: FloorOpeningHint[];
+};
+export declare function removeFloorOpening(nodes: StructureNodes, id: string): StructurePlan & {
+    openingId: string;
+};
+//# sourceMappingURL=floor-opening.d.ts.map

package/dist/commands/structure/floor-opening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/floor-opening.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,IAAI,EAAS,MAAM,2BAA2B,CAAA;AAChF,OAAO,EAAgC,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,CAAC,EAAE,IAAI,CAAA;IACd,IAAI,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7D,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,gBAAgB,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,gBAAgB,GACxB,gBAAgB,EAAE,CAwBpB;AAmBD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,oBAAoB,GAC1B,aAAa,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAoErE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,EAAE,EAAE,MAAM,GACT,aAAa,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAmBvC"}

package/dist/commands/structure/floor-opening.js

@@ -0,0 +1,124 @@
+import { adjacentLevelId, floorOpeningTargets } from '../../lib/floor-opening-intent.js';
+import { area, intersection, union } from '../../lib/polygon-boolean.js';
+import { FloorOpeningNode } from '../../schema/index.js';
+function surfaceFootprint(node) {
+    return { outer: node.polygon, holes: node.holes ?? [] };
+}
+export function floorOpeningHints(nodes, opening) {
+    const ceilingTargets = floorOpeningTargets(nodes, opening).filter((target) => target.surface === 'ceiling');
+    const surfaceIds = Object.values(nodes)
+        .filter((node) => node.type === 'ceiling' &&
+        node.boundary !== 'auto' &&
+        ceilingTargets.some((target) => target.levelId === node.parentId) &&
+        area(intersection(opening.polygon, surfaceFootprint(node))) > 1e-6)
+        .map((node) => node.id)
+        .sort();
+    return surfaceIds.length
+        ? [
+            {
+                code: 'manual-ceiling',
+                openingId: opening.id,
+                surfaceIds,
+                message: 'The adjacent ceiling is manual. Cut it in Edit ceiling.',
+            },
+        ]
+        : [];
+}
+function adjacentSurfaceExists(nodes, levelId, drawnOn, polygon) {
+    const adjacent = adjacentLevelId(nodes, levelId, drawnOn === 'floor' ? -1 : 1);
+    if (!adjacent)
+        return false;
+    return Object.values(nodes).some((node) => node.parentId === adjacent &&
+        (drawnOn === 'floor' ? node.type === 'ceiling' : node.type === 'slab') &&
+        (node.type === 'ceiling' || node.type === 'slab') &&
+        area(intersection(polygon, surfaceFootprint(node))) > 1e-6);
+}
+export function cutFloorOpening(nodes, input) {
+    const zone = input.zoneId ? nodes[input.zoneId] : undefined;
+    if (input.zoneId && (zone?.type !== 'zone' || zone.spaceRole !== 'room'))
+        throw Error(`Room not found: ${input.zoneId}`);
+    const levelIds = [...new Set(input.levelIds ?? [input.levelId ?? zone?.parentId ?? ''])];
+    if (!levelIds.length || levelIds.some((id) => nodes[id]?.type !== 'level'))
+        throw Error('Specify an existing levelId or room zoneId.');
+    if (zone && input.levelId && zone.parentId !== input.levelId)
+        throw Error('The room is not on the specified level.');
+    const polygon = input.polygon ??
+        (input.rect
+            ? [
+                [input.rect.x, input.rect.z],
+                [input.rect.x + input.rect.width, input.rect.z],
+                [input.rect.x + input.rect.width, input.rect.z + input.rect.depth],
+                [input.rect.x, input.rect.z + input.rect.depth],
+            ]
+            : undefined);
+    if (!polygon || polygon.length < 3 || !polygon.every((point) => point.every(Number.isFinite)))
+        throw Error('Supply a finite polygon with at least three vertices, or a rect.');
+    if (area(union([polygon])) <= 1e-6)
+        throw Error('The opening polygon has no area.');
+    const drawnOn = input.drawnOn ?? 'floor';
+    if (zone?.type === 'zone' && zone.floor?.support === 'open' && drawnOn !== 'floor')
+        throw Error('A mezzanine hatch must be drawn on its floor.');
+    const openings = levelIds.map((levelId) => {
+        const hostZoneId = zone?.type === 'zone' && zone.floor?.support === 'open' && zone.parentId === levelId
+            ? zone.id
+            : undefined;
+        const id = input.mintId('floor-opening');
+        if (nodes[id])
+            throw Error(`Duplicate opening id: ${id}`);
+        return FloorOpeningNode.parse({
+            id,
+            parentId: levelId,
+            name: 'Floor opening',
+            polygon,
+            ...(hostZoneId ? { hostZoneId } : {}),
+            source: input.source ?? 'manual',
+            ownerId: input.ownerId,
+            drawnOn,
+            cutsPrimary: input.cutsPrimary ?? true,
+            cutsAdjacent: hostZoneId !== undefined
+                ? false
+                : (input.cutsAdjacent ?? adjacentSurfaceExists(nodes, levelId, drawnOn, polygon)),
+        });
+    });
+    const levelUpdates = levelIds.map((levelId) => {
+        const level = nodes[levelId];
+        return {
+            op: 'update',
+            id: level.id,
+            data: {
+                children: [
+                    ...level.children,
+                    ...openings
+                        .filter((opening) => opening.parentId === levelId)
+                        .map((opening) => opening.id),
+                ],
+            },
+        };
+    });
+    return {
+        changes: [...openings.map((node) => ({ op: 'create', node })), ...levelUpdates],
+        openingIds: openings.map((opening) => opening.id),
+        hints: openings.flatMap((opening) => floorOpeningHints(nodes, opening)),
+    };
+}
+export function removeFloorOpening(nodes, id) {
+    const opening = nodes[id];
+    if (opening?.type !== 'floor-opening')
+        throw Error(`Floor opening not found: ${id}`);
+    const level = opening.parentId ? nodes[opening.parentId] : undefined;
+    return {
+        openingId: id,
+        changes: [
+            { op: 'delete', id: opening.id },
+            ...(level?.type === 'level'
+                ? [
+                    {
+                        op: 'update',
+                        id: level.id,
+                        data: { children: level.children.filter((child) => child !== id) },
+                    },
+                ]
+                : []),
+        ],
+    };
+}

package/dist/commands/structure/index.d.ts

@@ -0,0 +1,22 @@
+export { applyZoneTransformPlan, type CeilingHostAssignment, type HostedZoneTransformPlan, resolveZoneTransformHosts, type SupportHostAssignment, } from './apply-zone-transform.js';
+export { type CreateMezzanineInput, createMezzanine } from './create-mezzanine.js';
+export { type CreateZoneInput, createZone, outdoorRoomConflicts, walledRoomAt, } from './create-zone.js';
+export { type DeleteZonePayload, deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
+export { createZoneDivisionContext, divideZone, snapZoneBoundary, type ZoneDivisionContext, } from './divide-zone.js';
+export { type DuplicateZoneInput, duplicateZone } from './duplicate-zone.js';
+export { type CutFloorOpeningInput, cutFloorOpening, type FloorOpeningHint, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
+export { type LockOutsideFacesInput, lockOutsideFaces } from './lock-outside-faces.js';
+export { mergeZones } from './merge-zones.js';
+export { type MezzanineStairPlan, planMezzanineStair } from './plan-mezzanine-stair.js';
+export { planWallDeletion } from './plan-wall-deletion.js';
+export { rebaseFloorReference } from './rebase-floor-reference.js';
+export type { MezzanineEdgeInput } from './resize-mezzanine.js';
+export { type RotateZoneInput, rotateZone } from './rotate-zone.js';
+export { DEFAULT_FOUNDATION_HEIGHT, DEFAULT_FOUNDATION_MATERIAL, FloorFoundationPatch, setFloorFoundation, } from './set-floor-foundation.js';
+export { setRoomFloorConstruction } from './set-room-floor-construction.js';
+export { setWallGeometry } from './set-wall-geometry.js';
+export { setZoneEdges } from './set-zone-edges.js';
+export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
+export { type NodeChange, type Point, type SpanRef, type StructureConflict, type StructureMintId, type StructureNodes, type StructurePlan, structureChangeBatch, } from './shared.js';
+export { type TransformZoneInput, transformZone, type ZoneTransformPlan } from './transform-zone.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/structure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,KAAK,oBAAoB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EACL,KAAK,eAAe,EACpB,UAAU,EACV,oBAAoB,EACpB,YAAY,GACb,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EACL,yBAAyB,EACzB,UAAU,EACV,gBAAgB,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,eAAe,EACf,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,KAAK,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,oBAAoB,GACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/commands/structure/index.js

@@ -0,0 +1,20 @@
+export { applyZoneTransformPlan, resolveZoneTransformHosts, } from './apply-zone-transform.js';
+export { createMezzanine } from './create-mezzanine.js';
+export { createZone, outdoorRoomConflicts, walledRoomAt, } from './create-zone.js';
+export { deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
+export { createZoneDivisionContext, divideZone, snapZoneBoundary, } from './divide-zone.js';
+export { duplicateZone } from './duplicate-zone.js';
+export { cutFloorOpening, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
+export { lockOutsideFaces } from './lock-outside-faces.js';
+export { mergeZones } from './merge-zones.js';
+export { planMezzanineStair } from './plan-mezzanine-stair.js';
+export { planWallDeletion } from './plan-wall-deletion.js';
+export { rebaseFloorReference } from './rebase-floor-reference.js';
+export { rotateZone } from './rotate-zone.js';
+export { DEFAULT_FOUNDATION_HEIGHT, DEFAULT_FOUNDATION_MATERIAL, FloorFoundationPatch, setFloorFoundation, } from './set-floor-foundation.js';
+export { setRoomFloorConstruction } from './set-room-floor-construction.js';
+export { setWallGeometry } from './set-wall-geometry.js';
+export { setZoneEdges } from './set-zone-edges.js';
+export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
+export { structureChangeBatch, } from './shared.js';
+export { transformZone } from './transform-zone.js';

package/dist/commands/structure/lock-outside-faces.d.ts

@@ -0,0 +1,12 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type LockOutsideFacesInput = {
+    levelId: string;
+    zoneIds?: never;
+} | {
+    zoneIds: string[];
+    levelId?: never;
+};
+export declare function lockOutsideFaces(nodes: StructureNodes, input: LockOutsideFacesInput): StructurePlan & {
+    wallIds: string[];
+};
+//# sourceMappingURL=lock-outside-faces.d.ts.map

package/dist/commands/structure/lock-outside-faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-outside-faces.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/lock-outside-faces.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEzF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GACpC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAE1C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,qBAAqB,GAC3B,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA+BvC"}

package/dist/commands/structure/lock-outside-faces.js

@@ -0,0 +1,32 @@
+import { justificationForFaceOnLine, planWallJustification } from '../../systems/wall/wall-frame.js';
+import { roomSideFaces } from '../../systems/wall/wall-room-sides.js';
+import { requireZone, roomFace } from './shared.js';
+export function lockOutsideFaces(nodes, input) {
+    if (input.levelId && nodes[input.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    const zones = input.zoneIds?.map((id) => requireZone(nodes, id)) ??
+        Object.values(nodes).filter((node) => node.type === 'zone' && node.spaceRole === 'room' && node.parentId === input.levelId);
+    const targets = new Set(input.levelId
+        ? Object.values(nodes)
+            .filter((node) => node.type === 'wall' && node.parentId === input.levelId)
+            .map((node) => node.id)
+        : []);
+    for (const zone of zones) {
+        if (zone.type !== 'zone')
+            continue;
+        for (const span of roomFace(nodes, zone)?.spans ?? [])
+            if (span.kind === 'wall')
+                targets.add(span.boundaryId);
+    }
+    const patches = [];
+    for (const wallId of targets) {
+        const { outside } = roomSideFaces(nodes, wallId);
+        if (!outside)
+            continue;
+        patches.push(...planWallJustification(nodes, wallId, justificationForFaceOnLine(outside)));
+    }
+    return {
+        changes: patches.map((patch) => ({ op: 'update', ...patch })),
+        wallIds: patches.map((patch) => patch.id),
+    };
+}

package/dist/commands/structure/merge-zones.d.ts

@@ -0,0 +1,5 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare function mergeZones(nodes: StructureNodes, input: {
+    zoneIds: [string, string];
+}): StructurePlan;
+//# sourceMappingURL=merge-zones.d.ts.map

package/dist/commands/structure/merge-zones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-zones.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/merge-zones.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACnC,aAAa,CAoCf"}

package/dist/commands/structure/merge-zones.js

@@ -0,0 +1,22 @@
+import { extractRooms } from '../../lib/room-graph.js';
+import { boundaries, conflict, requireZone, roomFace, } from './shared.js';
+export function mergeZones(nodes, input) {
+    const [a, b] = input.zoneIds.map((id) => requireZone(nodes, id));
+    if (a.id === b.id || a.parentId !== b.parentId)
+        return conflict('different-levels', input.zoneIds, 'Select two different rooms on the same level.');
+    const left = roomFace(nodes, a)?.spans ?? [];
+    const right = roomFace(nodes, b)?.spans ?? [];
+    const common = left.filter((s) => right.some((r) => r.boundaryId === s.boundaryId &&
+        r.face !== s.face &&
+        Math.min(r.t1, s.t1) - Math.max(r.t0, s.t0) > 1e-6));
+    const separators = new Set(common.filter((s) => s.kind === 'separator').map((s) => s.boundaryId));
+    if (!separators.size)
+        return conflict('wall-boundary', common.map((s) => s.boundaryId), common.length
+            ? 'These rooms are separated by walls. Merge never removes walls.'
+            : 'These rooms do not share a separator.');
+    const before = boundaries(nodes, a.parentId);
+    const after = before.filter((n) => !separators.has(n.id));
+    if (extractRooms(after).length !== extractRooms(before).length - 1)
+        return conflict('shared-separator', [...separators], 'Removing these separators would affect additional rooms.');
+    return { changes: [...separators].map((id) => ({ op: 'delete', id: nodes[id].id })) };
+}

package/dist/commands/structure/mezzanine-content.d.ts

@@ -0,0 +1,16 @@
+import { type AnyNode, type SlabNode, type ZoneNode } from '../../schema/index.js';
+import { type StructureNodes } from './shared.js';
+export type PositionedIntent = AnyNode & {
+    position: [number, number, number];
+    rotation: number | [number, number, number];
+    supportSlabId?: string;
+};
+export declare function isFloorPlacedIntent(node: AnyNode): node is PositionedIntent;
+export declare function containedMezzanines(nodes: StructureNodes, host: ZoneNode): ZoneNode[];
+export declare function mezzanineElevationConflict(nodes: StructureNodes, zone: ZoneNode): {
+    code: string;
+    nodeIds: `zone_${string}`[];
+    message: string;
+} | undefined;
+export declare function electedIntentPlate(nodes: StructureNodes, node: PositionedIntent): SlabNode | undefined;
+//# sourceMappingURL=mezzanine-content.d.ts.map

package/dist/commands/structure/mezzanine-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mezzanine-content.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/mezzanine-content.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AAKrB,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG;IACvC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,gBAAgB,CAsB3E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAcrF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ;;;;cAkB/E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,gBAAgB,GACrB,QAAQ,GAAG,SAAS,CAyCtB"}