@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/split-pointer.js

@@ -0,0 +1,95 @@
+import { commitWallSplit, hoverWallSplit, setWallSplitCuts } from './split-session';
+import { useWallSplit } from './split-store';
+// Pixels of continuous wheel travel per cut: a short trackpad swipe.
+const WHEEL_STEP_PX = 60;
+// A wheel event after this pause is a new notch or gesture and steps at once,
+// so each notch of a notched wheel is one cut whatever pixels the OS reports
+// for it; a continuous stream (trackpad, fast spin) steps by travel.
+const WHEEL_GESTURE_GAP_MS = 80;
+/** Both viewports feed a wall distance; neither writes scene nodes while hovering. */
+export function bindWallSplitPointer(surface, distanceAt) {
+    let pressed = null;
+    let wheelTravel = 0;
+    let lastWheelAt = Number.NEGATIVE_INFINITY;
+    const move = (event) => {
+        if (event.buttons && pressed !== event.pointerId)
+            return;
+        const distance = distanceAt(event);
+        if (distance !== null)
+            hoverWallSplit(distance, event.altKey);
+    };
+    const down = (event) => {
+        if (event.button !== 0)
+            return;
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        pressed = event.pointerId;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        hoverWallSplit(distance, event.altKey);
+    };
+    const up = (event) => {
+        if (pressed !== event.pointerId)
+            return;
+        pressed = null;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        hoverWallSplit(distance, event.altKey);
+        // Retain ownership through the click dispatched after pointerup, so normal
+        // selection cannot consume that same click after the cut closes its session.
+        const swallow = (click) => {
+            click.preventDefault();
+            click.stopImmediatePropagation();
+        };
+        surface.addEventListener('click', swallow, { capture: true, once: true });
+        setTimeout(() => surface.removeEventListener('click', swallow, true), 0);
+        commitWallSplit();
+    };
+    const cancel = () => {
+        pressed = null;
+    };
+    // Scrolling over the viewport changes the cut count, as in a loop cut;
+    // pinch (Ctrl + wheel) still zooms.
+    const wheel = (event) => {
+        if (event.ctrlKey || !(event.target instanceof Node) || !surface.contains(event.target))
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (!event.deltaY)
+            return;
+        const fresh = event.timeStamp - lastWheelAt > WHEEL_GESTURE_GAP_MS;
+        lastWheelAt = event.timeStamp;
+        let steps;
+        // Line-mode deltas only come from a notched wheel: one line event, one notch.
+        if (fresh || event.deltaMode !== 0) {
+            wheelTravel = 0;
+            steps = Math.sign(event.deltaY);
+        }
+        else {
+            wheelTravel += event.deltaY;
+            steps = Math.trunc(wheelTravel / WHEEL_STEP_PX);
+            wheelTravel -= steps * WHEEL_STEP_PX;
+        }
+        if (!steps)
+            return;
+        const draft = useWallSplit.getState().draft;
+        if (draft)
+            setWallSplitCuts(draft.cuts - steps);
+    };
+    window.addEventListener('pointermove', move, true);
+    window.addEventListener('pointerdown', down, true);
+    window.addEventListener('pointerup', up, true);
+    window.addEventListener('pointercancel', cancel, true);
+    window.addEventListener('wheel', wheel, { capture: true, passive: false });
+    return () => {
+        window.removeEventListener('pointermove', move, true);
+        window.removeEventListener('pointerdown', down, true);
+        window.removeEventListener('pointerup', up, true);
+        window.removeEventListener('pointercancel', cancel, true);
+        window.removeEventListener('wheel', wheel, true);
+    };
+}

package/dist/wall/split-preview.d.ts

@@ -0,0 +1,55 @@
+import { type AnyNode, type AnyNodeId, type WallNode, type WallPlanPoint } from '@pascal-app/core';
+export declare const WALL_SPLIT_MAX_CUTS = 32;
+/** Cut markers in both views: warm when the cuts can commit, red when they can't. */
+export declare function wallSplitMarkerColor(valid: boolean): "#c86f45" | "#a63d2e";
+/** The pointer projected onto the wall, as a distance from its start; curved walls included. */
+export declare function wallSplitDistance(wall: WallNode, point: readonly [number, number]): number;
+/** Like a loop cut: one cut follows the pointer, more cuts divide the wall evenly. */
+export declare function wallSplitDistances(length: number, cuts: number, distance: number): number[];
+export type WallSplitSnap = {
+    kind: 'grid';
+} | {
+    kind: 'midpoint';
+} | {
+    kind: 'alignment';
+    anchor: WallPlanPoint;
+} | null;
+export type WallSplitSnapOptions = {
+    /** Grid step while the 'grid' snapping mode is active. */
+    gridStep: number | null;
+    /** Other wall ends to align with while the 'lines' mode is active. */
+    anchors: readonly WallPlanPoint[] | null;
+    /** How far (m) the pointer may be from an alignment target to catch it. */
+    tolerance: number;
+};
+/**
+ * Snaps a single cut along its wall with the active snapping mode: grid steps
+ * counted from the wall start, or — in 'lines' — the midpoint and where the
+ * level's other wall ends project onto the wall.
+ */
+export declare function snapWallSplitDistance(wall: WallNode, raw: number, options: WallSplitSnapOptions): {
+    distance: number;
+    snap: WallSplitSnap;
+};
+/** Ends of the level's other walls, for 'lines' alignment. */
+export declare function wallSplitAnchors(nodes: Record<AnyNodeId, AnyNode>, wall: WallNode): WallPlanPoint[];
+export declare function wallSplitPreview(nodes: Record<AnyNodeId, AnyNode>, wall: WallNode, distances: readonly number[]): {
+    distances: number[];
+    length: number;
+    frames: {
+        point: import("@pascal-app/core").Point2D;
+        tangent: import("@pascal-app/core").Point2D;
+        normal: import("@pascal-app/core").Point2D;
+    }[];
+    valid: boolean;
+    message: string;
+};
+export type WallSplitPreview = ReturnType<typeof wallSplitPreview>;
+/** What to label: both sides of a single cut, or one length repeated across even cuts. */
+export declare function wallSplitSegmentLabels(wall: WallNode, preview: WallSplitPreview): {
+    length: number;
+    count: number;
+    midpoint: WallPlanPoint;
+    direction: WallPlanPoint;
+}[];
+//# sourceMappingURL=split-preview.d.ts.map

package/dist/wall/split-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-preview.d.ts","sourceRoot":"","sources":["../../src/wall/split-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAKd,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,yBAElD;AAID,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAuB1F;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAG3F;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAC5C,IAAI,CAAA;AAER,MAAM,MAAM,oBAAoB,GAAG;IACjC,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,sEAAsE;IACtE,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,CAAA;IACxC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,oBAAoB,GAC5B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,CAyB3C;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,QAAQ,GACb,aAAa,EAAE,CAQjB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,SAAS,MAAM,EAAE;;;;;;;;;;EAqB7B;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAElE,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB;;;cAY1C,aAAa;eACR,aAAa;IAGvD"}

package/dist/wall/split-preview.js

@@ -0,0 +1,106 @@
+import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, planWallDivisions, } from '@pascal-app/core';
+export const WALL_SPLIT_MAX_CUTS = 32;
+/** Cut markers in both views: warm when the cuts can commit, red when they can't. */
+export function wallSplitMarkerColor(valid) {
+    return valid ? '#c86f45' : '#a63d2e';
+}
+// The planner refuses cuts closer than this to either end.
+const END_CLEARANCE = 0.05;
+/** The pointer projected onto the wall, as a distance from its start; curved walls included. */
+export function wallSplitDistance(wall, point) {
+    const length = getWallCurveLength(wall);
+    const arc = getWallArcData(wall);
+    if (arc) {
+        const angle = Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x);
+        const turn = Math.PI * 2;
+        const delta = (((arc.direction * (angle - arc.startAngle)) % turn) + turn) % turn;
+        if (delta <= Math.abs(arc.delta))
+            return (delta / Math.abs(arc.delta)) * length;
+        return Math.hypot(point[0] - wall.start[0], point[1] - wall.start[1]) <=
+            Math.hypot(point[0] - wall.end[0], point[1] - wall.end[1])
+            ? 0
+            : length;
+    }
+    if (length === 0)
+        return 0;
+    return Math.max(0, Math.min(length, ((point[0] - wall.start[0]) * (wall.end[0] - wall.start[0]) +
+        (point[1] - wall.start[1]) * (wall.end[1] - wall.start[1])) /
+        length));
+}
+/** Like a loop cut: one cut follows the pointer, more cuts divide the wall evenly. */
+export function wallSplitDistances(length, cuts, distance) {
+    if (cuts <= 1)
+        return [distance];
+    return Array.from({ length: cuts }, (_, index) => (length * (index + 1)) / (cuts + 1));
+}
+/**
+ * Snaps a single cut along its wall with the active snapping mode: grid steps
+ * counted from the wall start, or — in 'lines' — the midpoint and where the
+ * level's other wall ends project onto the wall.
+ */
+export function snapWallSplitDistance(wall, raw, options) {
+    const length = getWallCurveLength(wall);
+    const inside = (distance) => distance >= END_CLEARANCE && distance <= length - END_CLEARANCE;
+    if (options.gridStep) {
+        const snapped = Math.round(raw / options.gridStep) * options.gridStep;
+        return inside(snapped)
+            ? { distance: snapped, snap: { kind: 'grid' } }
+            : { distance: raw, snap: null };
+    }
+    if (!options.anchors)
+        return { distance: raw, snap: null };
+    let best = {
+        distance: raw,
+        snap: null,
+        gap: options.tolerance,
+    };
+    const consider = (distance, snap) => {
+        const gap = Math.abs(distance - raw);
+        if (gap < best.gap && inside(distance))
+            best = { distance, snap, gap };
+    };
+    consider(length / 2, { kind: 'midpoint' });
+    for (const anchor of options.anchors) {
+        consider(wallSplitDistance(wall, anchor), { kind: 'alignment', anchor });
+    }
+    return { distance: best.distance, snap: best.snap };
+}
+/** Ends of the level's other walls, for 'lines' alignment. */
+export function wallSplitAnchors(nodes, wall) {
+    const own = (point) => [wall.start, wall.end].some((end) => end[0] === point[0] && end[1] === point[1]);
+    return Object.values(nodes).flatMap((node) => node.type === 'wall' && node.id !== wall.id && node.parentId === wall.parentId
+        ? [node.start, node.end].filter((point) => !own(point))
+        : []);
+}
+export function wallSplitPreview(nodes, wall, distances) {
+    const length = getWallCurveLength(wall);
+    const frames = distances.map((distance) => getWallCurveFrameAt(wall, length > 0 ? distance / length : 0));
+    let message = '';
+    if ([wall, ...Object.values(nodes).filter((n) => n.parentId === wall.id)].some((n) => n.metadata.arrayModifier || n.metadata.linkedArray)) {
+        message = 'Make the linked array real before splitting this wall.';
+    }
+    else {
+        try {
+            planWallDivisions(nodes, wall.id, distances);
+        }
+        catch (error) {
+            message = error instanceof Error ? error.message : 'This wall cannot be split here.';
+        }
+    }
+    return { distances: [...distances], length, frames, valid: !message, message };
+}
+/** What to label: both sides of a single cut, or one length repeated across even cuts. */
+export function wallSplitSegmentLabels(wall, preview) {
+    const bounds = [0, ...preview.distances, preview.length];
+    const segments = bounds.slice(1).map((end, index) => [bounds[index], end]);
+    const count = preview.distances.length === 1 ? 1 : segments.length;
+    return (count === 1 ? segments : segments.slice(0, 1)).map(([from, to]) => {
+        const { point, tangent } = getWallCurveFrameAt(wall, preview.length > 0 ? (from + to) / 2 / preview.length : 0);
+        return {
+            length: to - from,
+            count,
+            midpoint: [point.x, point.y],
+            direction: [tangent.x, tangent.y],
+        };
+    });
+}

package/dist/wall/split-session.d.ts

@@ -0,0 +1,16 @@
+import { type WallNode } from '@pascal-app/core';
+/**
+ * A split session: the wall's `reshaping` scope (so the snapping chip and the
+ * kind's HUD hints resolve), one centred cut, and the watchers that end it —
+ * Esc, the wall or its edit rights going away, another interaction, leaving
+ * select mode. Both views render the same draft; either can commit.
+ */
+export declare function openWallSplit(wall: WallNode): void;
+export declare function closeWallSplit(): void;
+/** Pointer projected onto the wall; Alt (`free`) skips snapping. */
+export declare function hoverWallSplit(raw: number, free?: boolean): void;
+export declare function setWallSplitCuts(cuts: number): void;
+/** Re-plan against the current scene (after an external edit). */
+export declare function refreshWallSplit(): void;
+export declare function commitWallSplit(): void;
+//# sourceMappingURL=split-session.d.ts.map

package/dist/wall/split-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-session.d.ts","sourceRoot":"","sources":["../../src/wall/split-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA4CzB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,QA8C3C;AAED,wBAAgB,cAAc,SAS7B;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,QAevD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,QAQ5C;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,SAM/B;AAED,wBAAgB,eAAe,SAc9B"}

package/dist/wall/split-session.js

@@ -0,0 +1,144 @@
+import { getWallCurveLength, planWallDivisions, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+import { captureElementActionOrigin, completeElementAction, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { snapWallSplitDistance, WALL_SPLIT_MAX_CUTS, wallSplitAnchors, wallSplitDistances, wallSplitPreview, } from './split-preview';
+import { useWallSplit } from './split-store';
+// Pointer distance (m) within which a 'lines' alignment target catches the cut.
+const ALIGNMENT_TOLERANCE = 0.2;
+const ownsSplit = () => {
+    const { scope } = useInteractionScope.getState();
+    return scope.kind === 'reshaping' && scope.reshape === 'split';
+};
+const currentWall = (draft) => {
+    const wall = useScene.getState().nodes[draft.wallId];
+    return wall?.type === 'wall' ? wall : null;
+};
+const withPreview = (draft, wall) => ({
+    ...draft,
+    preview: wallSplitPreview(useScene.getState().nodes, wall, wallSplitDistances(getWallCurveLength(wall), draft.cuts, draft.distance)),
+});
+let teardown = null;
+// The room the wall was drilled from: a committed split lands back on it.
+let origin = null;
+/**
+ * A split session: the wall's `reshaping` scope (so the snapping chip and the
+ * kind's HUD hints resolve), one centred cut, and the watchers that end it —
+ * Esc, the wall or its edit rights going away, another interaction, leaving
+ * select mode. Both views render the same draft; either can commit.
+ */
+export function openWallSplit(wall) {
+    if (useScene.getState().readOnly)
+        return;
+    closeWallSplit();
+    origin = captureElementActionOrigin([wall.id]);
+    useEditor.getState().setMode('select');
+    useInteractionScope
+        .getState()
+        .begin({ kind: 'reshaping', nodeId: wall.id, reshape: 'split', driver: 'tool' });
+    useWallSplit
+        .getState()
+        .setDraft(withPreview({ wallId: wall.id, cuts: 1, distance: getWallCurveLength(wall) / 2, snap: null }, wall));
+    const onKey = (event) => {
+        if (event.key !== 'Escape')
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        closeWallSplit();
+    };
+    const stopScene = useScene.subscribe((state, previous) => {
+        if (state.readOnly || state.nodes[wall.id]?.type !== 'wall')
+            closeWallSplit();
+        else if (state.nodes !== previous.nodes)
+            refreshWallSplit();
+    });
+    const stopScope = useInteractionScope.subscribe(({ scope }) => {
+        if (!(scope.kind === 'reshaping' && scope.reshape === 'split'))
+            closeWallSplit();
+    });
+    const stopEditor = useEditor.subscribe((state) => {
+        if (state.mode !== 'select' ||
+            state.isCaptureMode ||
+            state.isPreviewMode ||
+            state.isFirstPersonMode)
+            closeWallSplit();
+    });
+    const hasWindow = typeof window !== 'undefined';
+    if (hasWindow)
+        window.addEventListener('keydown', onKey, true);
+    teardown = () => {
+        if (hasWindow)
+            window.removeEventListener('keydown', onKey, true);
+        stopScene();
+        stopScope();
+        stopEditor();
+    };
+}
+export function closeWallSplit() {
+    const stop = teardown;
+    teardown = null;
+    origin = null;
+    stop?.();
+    useWallSplit.getState().setDraft(null);
+    useInteractionScope
+        .getState()
+        .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'split');
+}
+/** Pointer projected onto the wall; Alt (`free`) skips snapping. */
+export function hoverWallSplit(raw, free = false) {
+    const draft = useWallSplit.getState().draft;
+    // Several cuts stay evenly spaced, so the pointer has nothing to move.
+    if (!draft || draft.cuts > 1 || !ownsSplit())
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    const { distance, snap } = free
+        ? { distance: raw, snap: null }
+        : snapWallSplitDistance(wall, raw, {
+            gridStep: isGridSnapActive() ? useEditor.getState().gridSnapStep : null,
+            anchors: isMagneticSnapActive() ? wallSplitAnchors(useScene.getState().nodes, wall) : null,
+            tolerance: ALIGNMENT_TOLERANCE,
+        });
+    if (distance === draft.distance && snap?.kind === draft.snap?.kind)
+        return;
+    useWallSplit.getState().setDraft(withPreview({ ...draft, distance, snap }, wall));
+}
+export function setWallSplitCuts(cuts) {
+    const draft = useWallSplit.getState().draft;
+    if (!draft || !ownsSplit())
+        return;
+    const next = Math.min(WALL_SPLIT_MAX_CUTS, Math.max(1, Math.round(cuts)));
+    if (next === draft.cuts)
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    useWallSplit.getState().setDraft(withPreview({ ...draft, cuts: next }, wall));
+}
+/** Re-plan against the current scene (after an external edit). */
+export function refreshWallSplit() {
+    const draft = useWallSplit.getState().draft;
+    if (!draft)
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    useWallSplit.getState().setDraft(withPreview(draft, wall));
+}
+export function commitWallSplit() {
+    const draft = useWallSplit.getState().draft;
+    const current = useScene.getState();
+    if (!draft || current.readOnly || !ownsSplit())
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    const checked = withPreview(draft, wall);
+    if (!checked.preview.valid)
+        return useWallSplit.getState().setDraft(checked);
+    const plan = planWallDivisions(current.nodes, wall.id, checked.preview.distances);
+    const from = origin;
+    runAsSingleSceneHistoryStep(useScene, () => current.applyNodeChanges(plan.changes));
+    closeWallSplit();
+    triggerSFX('sfx:structure-build');
+    completeElementAction(from);
+}

package/dist/wall/split-store.d.ts

@@ -0,0 +1,16 @@
+import type { WallNode } from '@pascal-app/core';
+import type { WallSplitPreview, WallSplitSnap } from './split-preview';
+export type WallSplitDraft = {
+    wallId: WallNode['id'];
+    cuts: number;
+    /** The single cut's snapped distance from the wall start; more cuts are evenly spaced. */
+    distance: number;
+    snap: WallSplitSnap;
+    preview: WallSplitPreview;
+};
+/** The open split's cut preview. Every transition lives in `split-session.ts`. */
+export declare const useWallSplit: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    draft: WallSplitDraft | null;
+    setDraft: (draft: WallSplitDraft | null) => void;
+}>>;
+//# sourceMappingURL=split-store.d.ts.map

package/dist/wall/split-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-store.d.ts","sourceRoot":"","sources":["../../src/wall/split-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEtE,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,kFAAkF;AAClF,eAAO,MAAM,YAAY;WAChB,cAAc,GAAG,IAAI;cAClB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI;GAI/C,CAAA"}

package/dist/wall/split-store.js

@@ -0,0 +1,6 @@
+import { create } from 'zustand';
+/** The open split's cut preview. Every transition lives in `split-session.ts`. */
+export const useWallSplit = create((set) => ({
+    draft: null,
+    setDraft: (draft) => set({ draft }),
+}));

package/dist/wall/split-tool.d.ts

@@ -0,0 +1,10 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * The wall's `split` affordance (3D): cut markers, segment lengths and the
+ * pointer binding. The session (`split-session.ts`) owns the scope and draft;
+ * the plan layer renders the same draft.
+ */
+export default function WallSplitTool(_props: {
+    node: AnyNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=split-tool.d.ts.map

package/dist/wall/split-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-tool.d.ts","sourceRoot":"","sources":["../../src/wall/split-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAA6C,MAAM,kBAAkB,CAAA;AAgB1F;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCA8J9D"}

package/dist/wall/split-tool.js

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getWallThickness, sceneRegistry, useScene } from '@pascal-app/core';
+import { DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, NO_RAYCAST, } from '@pascal-app/editor';
+import { BATCHED_LAYER, getSceneTheme, SCENE_LAYER, useViewer } from '@pascal-app/viewer';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Raycaster, Vector2 } from 'three';
+import { bindWallSplitPointer } from './split-pointer';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
+import { useWallSplit } from './split-store';
+/**
+ * The wall's `split` affordance (3D): cut markers, segment lengths and the
+ * pointer binding. The session (`split-session.ts`) owns the scope and draft;
+ * the plan layer renders the same draft.
+ */
+export default function WallSplitTool(_props) {
+    const draft = useWallSplit((s) => s.draft);
+    const wallId = draft?.wallId;
+    const wall = useScene((s) => (draft ? s.nodes[draft.wallId] : undefined));
+    const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
+    const isDark = useViewer((s) => getSceneTheme(s.sceneTheme).appearance === 'dark');
+    const { gl, camera } = useThree();
+    const root = useRef(null);
+    const column = useRef(null);
+    const top = useRef(null);
+    const base = useRef(null);
+    useEffect(() => {
+        if (!wallId)
+            return;
+        const surface = gl.domElement;
+        const raycaster = new Raycaster();
+        raycaster.layers.set(SCENE_LAYER);
+        raycaster.layers.enable(BATCHED_LAYER);
+        const pointer = new Vector2();
+        return bindWallSplitPointer(surface, (event) => {
+            if (event.target !== surface)
+                return null;
+            const current = useScene.getState().nodes[wallId];
+            const object = sceneRegistry.nodes.get(wallId);
+            if (current?.type !== 'wall' || !object?.parent)
+                return null;
+            const rect = surface.getBoundingClientRect();
+            if (!rect.width || !rect.height)
+                return null;
+            pointer.set(((event.clientX - rect.left) / rect.width) * 2 - 1, 1 - ((event.clientY - rect.top) / rect.height) * 2);
+            raycaster.setFromCamera(pointer, camera);
+            object.updateWorldMatrix(true, true);
+            const hit = raycaster.intersectObject(object, true)[0];
+            if (!hit)
+                return null;
+            const local = object.parent.worldToLocal(hit.point.clone());
+            return wallSplitDistance(current, [local.x, local.z]);
+        });
+    }, [wallId, gl, camera]);
+    useFrame(() => {
+        if (!(root.current && column.current && top.current && base.current))
+            return;
+        if (wall?.type !== 'wall' || !draft)
+            return;
+        const object = sceneRegistry.nodes.get(wall.id);
+        if (!object?.parent || !object.geometry) {
+            root.current.visible = false;
+            return;
+        }
+        root.current.visible = true;
+        object.updateWorldMatrix(true, false);
+        root.current.matrix.copy(object.parent.matrixWorld);
+        if (!object.geometry.boundingBox)
+            object.geometry.computeBoundingBox();
+        const bounds = object.geometry.boundingBox;
+        const bottom = object.position.y + (bounds?.min.y ?? 0);
+        const height = bounds ? bounds.max.y - bounds.min.y : (wall.height ?? 3);
+        column.current.position.y = bottom + height / 2;
+        column.current.scale.y = Math.max(0.05, height + 0.05);
+        top.current.position.y = bottom + height + DRAFT_LABEL_Y_OFFSET;
+        base.current.position.y = bottom + 0.01;
+    });
+    if (!draft || wall?.type !== 'wall')
+        return null;
+    const { preview, snap } = draft;
+    const thickness = getWallThickness(wall);
+    const color = wallSplitMarkerColor(preview.valid);
+    const cut = preview.frames[0]?.point;
+    const guide = snap?.kind === 'alignment' && cut
+        ? {
+            x: (snap.anchor[0] + cut.x) / 2,
+            z: (snap.anchor[1] + cut.y) / 2,
+            length: Math.hypot(cut.x - snap.anchor[0], cut.y - snap.anchor[1]),
+            angle: -Math.atan2(cut.y - snap.anchor[1], cut.x - snap.anchor[0]),
+        }
+        : null;
+    return (_jsxs("group", { ref: root, matrixAutoUpdate: false, children: [_jsx("group", { ref: column, children: preview.frames.map(({ point, tangent }, index) => (_jsxs("group", { position: [point.x, 0, point.y], rotation: [0, -Math.atan2(tangent.y, tangent.x), 0], userData: { testId: 'pascal-split-marker', valid: preview.valid }, children: [_jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 8900, scale: [0.074, 1, thickness + 0.12], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: preview.valid ? '#f7f3ed' : '#faece9', depthTest: false, depthWrite: false, toneMapped: false })] }), _jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 8910, scale: [0.026, 1.001, thickness + 0.07], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, toneMapped: false })] })] }, index))) }), _jsx("group", { ref: top, children: !preview.valid && cut ? (_jsx(DraftMeasurementLabel, { color: color, label: preview.message, position: [cut.x, 0, cut.y], shadowColor: isDark ? '#111111' : '#ffffff' })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(DraftMeasurementLabel, { color: isDark ? '#ffffff' : '#111111', label: `${formatLinearMeasurement(segment.length, unit, metricNotation)}${segment.count > 1 ? ` × ${segment.count}` : ''}`, position: [segment.midpoint[0], 0, segment.midpoint[1]], shadowColor: isDark ? '#111111' : '#ffffff' }, index)))) }), _jsx("group", { ref: base, children: guide && (_jsxs("mesh", { layers: EDITOR_LAYER, position: [guide.x, 0, guide.z], raycast: NO_RAYCAST, renderOrder: 8890, rotation: [0, guide.angle, 0], scale: [guide.length, 0.01, 0.02], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.8, toneMapped: false, transparent: true })] })) })] }));
+}

package/dist/wall/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAuDA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CA0FhD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/system.js

@@ -1,9 +1,11 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { spatialGridManager, useLiveNodeOverrides, useLiveTerrain, useScene, } from '@pascal-app/core';
 import { timeSpan, WallCutout, WallSystem } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
 import { useEffect } from 'react';
+import { curtainWallGeometryAdapter } from './curtain-wall-adapter';
+import { getCurtainAwareWallMaterials } from './curtain-wall-materials';
 import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data';
 import { wallTreatmentProudOffsets } from './treatments';
 import { WallBatchSystem } from './wall-batch-system';
@@ -48,6 +50,10 @@ export function updateWallTreatmentLevels() {
         previousNodes = nodes;
         previousOverrides = overrides;
     }
+    const terrain = useLiveTerrain.getState();
+    const ancestors = dirtyLevelIds.size
+        ? Object.values(nodes).filter((node) => node.type === 'site' || node.type === 'building' || node.type === 'level')
+        : [];
     for (const levelId of dirtyLevelIds) {
         const level = nodes[levelId];
         if (level?.type !== 'level') {
@@ -63,13 +69,41 @@ export function updateWallTreatmentLevels() {
         const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
         const proudKey = treatmentProudKeys(proudOffsets).join(',');
         const previous = levelInputs.get(levelId);
-        if (previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls))
+        const sameWalls = previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls);
+        const supportInputs = [
+            ...ancestors,
+            ...level.children.flatMap((id) => {
+                const node = nodes[id];
+                return node && (node.type === 'slab' || node.type === 'zone' || node.type === 'separator')
+                    ? [node, overrides.get(id)]
+                    : [];
+            }),
+        ];
+        const sameSupportInputs = previous?.supportInputs.length === supportInputs.length &&
+            supportInputs.every((input, i) => input === previous.supportInputs[i]);
+        const sameTerrain = previous?.terrain === terrain;
+        if (sameWalls && sameSupportInputs && sameTerrain)
+            continue;
+        const supports = new Map(walls.map((wall) => {
+            const cached = sameSupportInputs &&
+                (sameTerrain || !dirtyNodes.has(wall.id)) &&
+                previous?.walls.includes(wall)
+                ? previous.supports.get(wall.id)
+                : undefined;
+            return [
+                wall.id,
+                cached ??
+                    spatialGridManager.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId, undefined, wall.supportOffset, wall.justification),
+            ];
+        }));
+        const supportKey = JSON.stringify([...supports].map(([id, support]) => [id, support.elevation, support.faceDatum]));
+        levelInputs.set(levelId, { walls, proudKey, supportKey, supportInputs, supports, terrain });
+        if (sameWalls && previous.supportKey === supportKey)
             continue;
         timeSpan('wall-treatment-level', () => {
             useWallTreatmentLevelData
                 .getState()
-                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets));
-            levelInputs.set(levelId, { walls, proudKey });
+                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets, supports));
         });
     }
 }
@@ -93,6 +127,6 @@ const WallTreatmentMiterSystem = () => {
  *    draw calls instead of one per wall face run.
  */
 const WallSystems = () => {
-    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, {}), _jsx(WallCutout, {}), _jsx(WallBatchSystem, {})] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, { geometryAdapter: curtainWallGeometryAdapter }), _jsx(WallCutout, { materialResolver: getCurtainAwareWallMaterials }), _jsx(WallBatchSystem, {})] }));
 };
 export default WallSystems;

package/dist/wall/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAuf5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAqhCA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAQ5B,CAAA;AAED,eAAe,QAAQ,CAAA"}