@pascal-app/core 1.0.1 → 1.0.4

package/dist/systems/owned-floor-openings.js

@@ -0,0 +1,326 @@
+import { canonicalOpeningRing } from '../lib/canonical-opening-ring.js';
+import { FloorOpeningNode as FloorOpeningSchema } from '../schema/nodes/floor-opening.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { getLevelElevations } from '../services/storey.js';
+import { syncAutoElevatorOpenings } from './elevator/elevator-opening-sync.js';
+import { syncAutoStairOpenings } from './stair/stair-opening-sync.js';
+import { resolveStairTotalRise } from './stair/stair-rise-query.js';
+function ownerPose(value) {
+    if (!value || typeof value !== 'object')
+        return;
+    const pose = value;
+    if (!Array.isArray(pose.position) ||
+        pose.position.length !== 3 ||
+        !pose.position.every((coordinate) => typeof coordinate === 'number' && Number.isFinite(coordinate)) ||
+        typeof pose.rotation !== 'number' ||
+        !Number.isFinite(pose.rotation) ||
+        typeof pose.width !== 'number' ||
+        !Number.isFinite(pose.width) ||
+        !(pose.width > 0) ||
+        typeof pose.runLength !== 'number' ||
+        !Number.isFinite(pose.runLength) ||
+        !(pose.runLength > 0))
+        return;
+    return pose;
+}
+function hashKey(key) {
+    let hash = 0xcbf29ce484222325n;
+    for (const byte of new TextEncoder().encode(key))
+        hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+    return `floor-opening_${hash.toString(36).padStart(16, '0')}`;
+}
+function ownerFor(metadata) {
+    return metadata.source === 'stair'
+        ? metadata.stairId
+        : metadata.source === 'elevator'
+            ? metadata.elevatorId
+            : undefined;
+}
+function withoutOwnedCuts(nodes) {
+    const stripped = { ...nodes };
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'slab' && node.type !== 'ceiling')
+            continue;
+        const kept = (node.holes ?? []).flatMap((hole, index) => {
+            const metadata = node.holeMetadata?.[index];
+            if (metadata?.source === 'stair' || metadata?.source === 'elevator')
+                return [];
+            if (metadata?.source === 'floor-opening' && metadata.openingId) {
+                const opening = nodes[metadata.openingId];
+                if (!opening ||
+                    (opening.type === 'floor-opening' &&
+                        (opening.source === 'stair' || opening.source === 'elevator')))
+                    return [];
+            }
+            return [{ hole, metadata: metadata ?? { source: 'manual' } }];
+        });
+        if (kept.length !== (node.holes ?? []).length)
+            stripped[node.id] = {
+                ...node,
+                holes: kept.map((entry) => entry.hole),
+                holeMetadata: kept.map((entry) => entry.metadata),
+            };
+    }
+    return stripped;
+}
+function desiredCuts(nodes) {
+    let draft = withoutOwnedCuts(nodes);
+    for (const derive of [syncAutoElevatorOpenings, syncAutoStairOpenings]) {
+        const updates = derive(draft);
+        if (!updates.length)
+            continue;
+        draft = { ...draft };
+        for (const { id, data } of updates)
+            draft[id] = { ...draft[id], ...data };
+    }
+    return cutsFromSurfaces(draft, nodes);
+}
+function cutsFromSurfaces(surfaces, owners) {
+    const cuts = [];
+    for (const surface of Object.values(surfaces)) {
+        if (surface.type !== 'slab' && surface.type !== 'ceiling')
+            continue;
+        for (const [index, polygon] of (surface.holes ?? []).entries()) {
+            const metadata = surface.holeMetadata?.[index];
+            if (metadata?.source !== 'stair' && metadata?.source !== 'elevator')
+                continue;
+            const ownerId = ownerFor(metadata);
+            if (ownerId && owners[ownerId]?.type === metadata.source)
+                cuts.push({ source: metadata.source, ownerId, surface, polygon });
+        }
+    }
+    return cuts;
+}
+export function planOwnedFloorOpenings(nodes, options = {}) {
+    const values = Object.values(nodes);
+    if (!values.some((node) => node.type === 'stair' ||
+        node.type === 'elevator' ||
+        (node.type === 'floor-opening' && (node.source === 'stair' || node.source === 'elevator'))))
+        return [];
+    const existing = values.filter((node) => node.type === 'floor-opening' &&
+        (node.source === 'stair' || node.source === 'elevator') &&
+        !!node.ownerId &&
+        !!node.surfaceId);
+    const authored = values.filter((node) => node.type === 'floor-opening' &&
+        (node.source === 'stair' || node.source === 'elevator') &&
+        !!node.ownerId &&
+        !node.surfaceId);
+    const eligible = (ownerId) => !options.ownerIds || options.ownerIds.has(ownerId);
+    const byLevel = new Map();
+    const elevations = options.enforceReach === false ? undefined : getLevelElevations(nodes);
+    for (const cut of options.materializedNodes
+        ? cutsFromSurfaces(options.materializedNodes, nodes)
+        : desiredCuts(nodes)) {
+        const owner = nodes[cut.ownerId];
+        if (!eligible(cut.ownerId))
+            continue;
+        const level = cut.surface.parentId ? nodes[cut.surface.parentId] : undefined;
+        if (options.skipExistingSurfaces &&
+            level?.type === 'level' &&
+            level.metadata?.legacyAutoOpeningsMigrated === true &&
+            !existing.some((opening) => opening.ownerId === cut.ownerId && opening.source === cut.source) &&
+            !(nodes[cut.surface.id]?.type === 'slab' || nodes[cut.surface.id]?.type === 'ceiling'
+                ? nodes[cut.surface.id].holeMetadata?.some((metadata) => metadata.source === cut.source && ownerFor(metadata) === cut.ownerId)
+                : false))
+            continue;
+        if (owner?.type === 'stair' && elevations) {
+            const from = elevations.get(owner.fromLevelId ?? owner.parentId ?? '');
+            const target = elevations.get(cut.surface.parentId ?? '');
+            if (from && target && from.buildingId === target.buildingId) {
+                const rise = resolveStairTotalRise(owner, nodes);
+                const surfaceHeight = cut.surface.type === 'slab'
+                    ? (cut.surface.elevation ?? 0.05)
+                    : resolveCeilingHeight(cut.surface, nodes);
+                const targetRise = target.baseY - from.baseY + surfaceHeight - owner.position[1];
+                if (rise + Math.max(0.35, (rise / Math.max(owner.stepCount, 1)) * 2) < targetRise)
+                    continue;
+            }
+        }
+        if (options.skipExistingSurfaces &&
+            existing.some((opening) => opening.ownerId === cut.ownerId && opening.source === cut.source))
+            continue;
+        if (authored.some((opening) => opening.source === cut.source &&
+            opening.ownerId === cut.ownerId &&
+            opening.parentId === cut.surface.parentId) &&
+            !existing.some((opening) => opening.source === cut.source &&
+                opening.ownerId === cut.ownerId &&
+                opening.parentId === cut.surface.parentId))
+            continue;
+        if (owner?.type === 'stair' && (owner.slabOpeningMode ?? 'none') !== 'destination')
+            continue;
+        if (!cut.surface.parentId)
+            continue;
+        const key = JSON.stringify([cut.source, cut.ownerId, cut.surface.parentId]);
+        byLevel.set(key, [...(byLevel.get(key) ?? []), cut]);
+    }
+    const patches = [];
+    const retained = new Set();
+    const addedByLevel = new Map();
+    const deletedByLevel = new Map();
+    for (const opening of authored) {
+        if (!eligible(opening.ownerId))
+            continue;
+        const owner = nodes[opening.ownerId];
+        if (!owner ||
+            owner.type !== opening.source ||
+            existing.some((candidate) => candidate.source === opening.source &&
+                candidate.ownerId === opening.ownerId &&
+                candidate.parentId === opening.parentId)) {
+            patches.push({ op: 'delete', id: opening.id });
+            if (opening.parentId) {
+                const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+                removed.add(opening.id);
+                deletedByLevel.set(opening.parentId, removed);
+            }
+            continue;
+        }
+        if (owner.type !== 'stair')
+            continue;
+        const oldPose = ownerPose(opening.metadata.ownerPose);
+        const segment = owner.children
+            .map((id) => nodes[id])
+            .find((node) => node?.type === 'stair-segment');
+        const runLength = segment?.type === 'stair-segment' ? segment.length : (oldPose?.runLength ?? 1);
+        const pose = {
+            position: owner.position,
+            rotation: owner.rotation,
+            width: owner.width,
+            runLength,
+        };
+        const target = opening.metadata.ownerOpeningTarget === 'source' || opening.drawnOn === 'ceiling'
+            ? owner.fromLevelId
+            : owner.toLevelId;
+        const parentId = target && nodes[target]?.type === 'level' ? target : opening.parentId;
+        const poseChanged = oldPose && JSON.stringify(oldPose) !== JSON.stringify(pose);
+        const polygon = poseChanged
+            ? canonicalOpeningRing(opening.polygon.map(([x, z]) => {
+                const dx = x - oldPose.position[0];
+                const dz = z - oldPose.position[2];
+                const cosOld = Math.cos(oldPose.rotation);
+                const sinOld = Math.sin(oldPose.rotation);
+                const localX = (dx * cosOld - dz * sinOld) * (owner.width / oldPose.width);
+                const localZ = (dx * sinOld + dz * cosOld) * (runLength / oldPose.runLength);
+                const cos = Math.cos(owner.rotation);
+                const sin = Math.sin(owner.rotation);
+                return [
+                    owner.position[0] + localX * cos + localZ * sin,
+                    owner.position[2] - localX * sin + localZ * cos,
+                ];
+            }))
+            : opening.polygon;
+        const metadata = { ...opening.metadata, ownerPose: pose };
+        const data = {};
+        if (JSON.stringify(polygon) !== JSON.stringify(opening.polygon))
+            data.polygon = polygon;
+        if (parentId !== opening.parentId) {
+            data.parentId = parentId;
+            if (opening.parentId) {
+                const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+                removed.add(opening.id);
+                deletedByLevel.set(opening.parentId, removed);
+            }
+            if (parentId)
+                addedByLevel.set(parentId, [...(addedByLevel.get(parentId) ?? []), opening.id]);
+        }
+        if (JSON.stringify(metadata) !== JSON.stringify(opening.metadata))
+            data.metadata = metadata;
+        if (Object.keys(data).length)
+            patches.push({ op: 'update', id: opening.id, data });
+    }
+    for (const [key, cuts] of byLevel) {
+        const [source, ownerId, levelId] = JSON.parse(key);
+        const siblings = existing
+            .filter((node) => node.source === source && node.ownerId === ownerId && node.parentId === levelId)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        cuts.sort((a, b) => Number(b.surface.type === 'slab') - Number(a.surface.type === 'slab') ||
+            a.surface.id.localeCompare(b.surface.id) ||
+            JSON.stringify(a.polygon).localeCompare(JSON.stringify(b.polygon)));
+        const old = siblings[0] ??
+            existing.find((node) => node.source === source &&
+                node.ownerId === ownerId &&
+                node.drawnOn === (cuts[0].surface.type === 'slab' ? 'floor' : 'ceiling') &&
+                !retained.has(node.id) &&
+                !byLevel.has(JSON.stringify([source, ownerId, node.parentId])));
+        const id = old?.id ?? hashKey(JSON.stringify([source, ownerId, levelId]));
+        const legacyPlateCuts = {};
+        const legacyCeilingCuts = {};
+        for (const cut of cuts) {
+            const map = cut.surface.type === 'slab' ? legacyPlateCuts : legacyCeilingCuts;
+            const rings = map[cut.surface.id] ?? [];
+            if (!rings.some((ring) => JSON.stringify(ring) === JSON.stringify(cut.polygon)))
+                map[cut.surface.id] = [...rings, cut.polygon];
+        }
+        const primary = cuts[0];
+        const candidate = FloorOpeningSchema.parse({
+            ...old,
+            id,
+            parentId: levelId,
+            name: source === 'stair' ? 'Stair opening' : 'Elevator opening',
+            polygon: canonicalOpeningRing(primary.polygon),
+            source,
+            ownerId,
+            surfaceId: primary.surface.id,
+            drawnOn: primary.surface.type === 'slab' ? 'floor' : 'ceiling',
+            cutsPrimary: true,
+            cutsAdjacent: false,
+            legacyPlateCuts: Object.keys(legacyPlateCuts).length ? legacyPlateCuts : undefined,
+            legacyCeilingCuts: Object.keys(legacyCeilingCuts).length ? legacyCeilingCuts : undefined,
+        });
+        retained.add(id);
+        if (old) {
+            const data = {};
+            for (const property of [
+                'parentId',
+                'surfaceId',
+                'polygon',
+                'legacyPlateCuts',
+                'legacyCeilingCuts',
+                'drawnOn',
+            ])
+                if (JSON.stringify(old[property]) !==
+                    JSON.stringify(candidate[property]))
+                    data[property] = candidate[property];
+            if (Object.keys(data).length)
+                patches.push({ op: 'update', id: old.id, data: data });
+            if (old.parentId !== candidate.parentId) {
+                if (old.parentId) {
+                    const removed = deletedByLevel.get(old.parentId) ?? new Set();
+                    removed.add(old.id);
+                    deletedByLevel.set(old.parentId, removed);
+                }
+                if (candidate.parentId)
+                    addedByLevel.set(candidate.parentId, [
+                        ...(addedByLevel.get(candidate.parentId) ?? []),
+                        old.id,
+                    ]);
+            }
+        }
+        else {
+            patches.push({ op: 'create', node: candidate });
+            if (candidate.parentId)
+                addedByLevel.set(candidate.parentId, [...(addedByLevel.get(candidate.parentId) ?? []), id]);
+        }
+    }
+    for (const opening of existing) {
+        if (!eligible(opening.ownerId) || retained.has(opening.id) || options.skipExistingSurfaces)
+            continue;
+        patches.push({ op: 'delete', id: opening.id });
+        if (opening.parentId) {
+            const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+            removed.add(opening.id);
+            deletedByLevel.set(opening.parentId, removed);
+        }
+    }
+    for (const levelId of new Set([...addedByLevel.keys(), ...deletedByLevel.keys()])) {
+        const level = nodes[levelId];
+        if (level?.type !== 'level')
+            continue;
+        const children = [
+            ...level.children.filter((id) => !deletedByLevel.get(levelId)?.has(id)),
+            ...(addedByLevel.get(levelId) ?? []),
+        ];
+        if (JSON.stringify(children) !== JSON.stringify(level.children))
+            patches.push({ op: 'update', id: level.id, data: { children } });
+    }
+    return patches;
+}

package/dist/systems/reconcile-owned-floor-openings.d.ts

@@ -0,0 +1,3 @@
+import type { NodePatch, SceneNodes } from '../lib/structure-kernel.js';
+export declare function reconcileOwnedFloorOpeningChanges(before: SceneNodes, changes: NodePatch[]): void;
+//# sourceMappingURL=reconcile-owned-floor-openings.d.ts.map

package/dist/systems/reconcile-owned-floor-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/reconcile-owned-floor-openings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAKpE,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,QAkBzF"}

package/dist/systems/reconcile-owned-floor-openings.js

@@ -0,0 +1,25 @@
+import { createFloorOpeningIndex, floorOpeningTargets } from '../lib/floor-opening-intent.js';
+import { applyStructureReconciliation } from '../lib/structure-commit.js';
+import { generateId } from '../schema/base.js';
+import useScene from '../store/use-scene.js';
+export function reconcileOwnedFloorOpeningChanges(before, changes) {
+    const after = useScene.getState().nodes;
+    const oldIndex = createFloorOpeningIndex(before);
+    const newIndex = createFloorOpeningIndex(after);
+    const levels = new Set();
+    for (const change of changes) {
+        const id = change.op === 'create' ? change.node.id : change.id;
+        for (const [nodes, index] of [
+            [before, oldIndex],
+            [after, newIndex],
+        ]) {
+            const opening = nodes[id];
+            if (opening?.type !== 'floor-opening')
+                continue;
+            for (const target of floorOpeningTargets(nodes, opening, index))
+                levels.add(target.levelId);
+        }
+    }
+    if (levels.size)
+        applyStructureReconciliation(useScene, { levelIds: [...levels], mintId: generateId });
+}

package/dist/systems/slab/__fixtures__/doorway-steps.d.ts

@@ -0,0 +1,8 @@
+import { type AnyNode } from '../../../schema/index.js';
+/**
+ * Three rooms in a row, A | B | C, a door in each dividing wall. B is raised,
+ * so it owns a step at each door: one toward A, one toward C. `open` divides B
+ * from C with a separator instead of a wall and door.
+ */
+export declare function doorwayStepsFixture(elevations?: [number, number, number], open?: boolean): Record<string, AnyNode>;
+//# sourceMappingURL=doorway-steps.d.ts.map

package/dist/systems/slab/__fixtures__/doorway-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doorway-steps.d.ts","sourceRoot":"","sources":["../../../../src/systems/slab/__fixtures__/doorway-steps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,iBAAiB,CAAA;AAGxB;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,EACxD,IAAI,UAAQ,GAgE+C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACnF"}

package/dist/systems/slab/__fixtures__/doorway-steps.js

@@ -0,0 +1,62 @@
+import { DoorNode, LevelNode, SeparatorNode, WallNode, ZoneNode, } from '../../../schema/index.js';
+import { reconcileStructureWithStableIds } from '../../../utils/structure-id.js';
+/**
+ * Three rooms in a row, A | B | C, a door in each dividing wall. B is raised,
+ * so it owns a step at each door: one toward A, one toward C. `open` divides B
+ * from C with a separator instead of a wall and door.
+ */
+export function doorwayStepsFixture(elevations = [0.05, 0.3, 0.05], open = false) {
+    const ring = (x0, x1) => [
+        [x0, 0],
+        [x1, 0],
+        [x1, 4],
+        [x0, 4],
+    ];
+    const outline = ring(0, 12);
+    const walls = outline.map((start, i) => WallNode.parse({
+        id: `wall_row_${i}`,
+        parentId: 'level_row',
+        start,
+        end: outline[(i + 1) % 4],
+        thickness: 0.2,
+    }));
+    const doors = ['ab', 'bc'].map((pair) => DoorNode.parse({
+        id: `door_${pair}`,
+        parentId: `wall_row_${pair}`,
+        wallId: `wall_row_${pair}`,
+        width: 1,
+        height: 2,
+        position: [2, 1, 0],
+    }));
+    const dividers = [4, 8].map((x, i) => WallNode.parse({
+        id: `wall_row_${i ? 'bc' : 'ab'}`,
+        parentId: 'level_row',
+        start: [x, 0],
+        end: [x, 4],
+        thickness: 0.2,
+        children: [doors[i].id],
+    }));
+    const zones = ['a', 'b', 'c'].map((name, i) => ZoneNode.parse({
+        id: `zone_${name}`,
+        parentId: 'level_row',
+        name: name.toUpperCase(),
+        spaceRole: 'room',
+        enclosureStatus: 'enclosed',
+        polygon: ring(i * 4, (i + 1) * 4),
+        floor: { elevation: elevations[i] },
+    }));
+    const separator = SeparatorNode.parse({
+        id: 'separator_bc',
+        parentId: 'level_row',
+        start: [8, 0],
+        end: [8, 4],
+    });
+    const children = [...walls, ...(open ? [dividers[0], separator] : dividers), ...zones];
+    const level = LevelNode.parse({
+        id: 'level_row',
+        height: 3,
+        children: children.map((node) => node.id),
+    });
+    const nodes = Object.fromEntries([level, ...children, ...(open ? doors.slice(0, 1) : doors)].map((node) => [node.id, node]));
+    return reconcileStructureWithStableIds({ nodes }).nodes;
+}