@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/shared/lean-to-post-omissions.js

@@ -0,0 +1,51 @@
+import { resolveLeanToLayout } from '../lean-to-extension/layout';
+function managedPostSlot(column) {
+    const metadata = column.metadata;
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return null;
+    if (metadata.leanToRole !== 'post' || typeof metadata.managedByLeanTo !== 'string')
+        return null;
+    if (typeof metadata.leanToPostIndex !== 'number' || !Number.isInteger(metadata.leanToPostIndex)) {
+        return null;
+    }
+    return {
+        side: metadata.leanToPostSide === 'high' ? 'high' : 'low',
+        index: metadata.leanToPostIndex,
+    };
+}
+export function isLeanToPostOmitted(leanTo, side, index) {
+    const currentCount = resolveLeanToLayout(leanTo).postXs.length;
+    return (leanTo.omittedPostSlots ?? []).some((slot) => {
+        if (slot.side !== side)
+            return false;
+        if (slot.index < 0 || index < 0)
+            return slot.index === index;
+        if (leanTo.hostKind === 'conical-roof') {
+            const normalized = slot.index / Math.max(1, slot.layoutCount);
+            return Math.round(normalized * currentCount) % currentCount === index;
+        }
+        const normalized = slot.index / Math.max(1, slot.layoutCount - 1);
+        return Math.round(normalized * Math.max(1, currentCount - 1)) === index;
+    });
+}
+export function leanToPostOmissionPatchesOnDelete(column, nodes) {
+    const slot = managedPostSlot(column);
+    if (!slot)
+        return [];
+    const metadata = column.metadata;
+    const leanTo = nodes[metadata.managedByLeanTo];
+    if (leanTo?.type !== 'lean-to-extension' || isLeanToPostOmitted(leanTo, slot.side, slot.index)) {
+        return [];
+    }
+    return [
+        {
+            id: leanTo.id,
+            data: {
+                omittedPostSlots: [
+                    ...(leanTo.omittedPostSlots ?? []),
+                    { ...slot, layoutCount: resolveLeanToLayout(leanTo).postXs.length },
+                ],
+            },
+        },
+    ];
+}

package/dist/shared/mep-fitting-actions.d.ts

@@ -0,0 +1,5 @@
+import type { NodeQuickAction, PipeFittingNode } from '@pascal-app/core';
+export declare function pipeFittingQuickActions({ node }: {
+    node: PipeFittingNode;
+}): NodeQuickAction[];
+//# sourceMappingURL=mep-fitting-actions.d.ts.map

package/dist/shared/mep-fitting-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mep-fitting-actions.d.ts","sourceRoot":"","sources":["../../src/shared/mep-fitting-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAY,MAAM,kBAAkB,CAAA;AAElF,wBAAgB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG,eAAe,EAAE,CAe9F"}

package/dist/shared/mep-fitting-actions.js

@@ -0,0 +1,16 @@
+export function pipeFittingQuickActions({ node }) {
+    if (node.fittingType === 'end-cap')
+        return [];
+    const variants = ['pvc', 'abs', 'cast-iron'].map((pipeMaterial) => ({
+        id: `pipe-fitting:material:${pipeMaterial}`,
+        label: pipeMaterial === 'cast-iron' ? 'Cast iron' : pipeMaterial.toUpperCase(),
+        title: `Use ${pipeMaterial.replace('-', ' ')} for this fitting`,
+        disabled: node.pipeMaterial === pipeMaterial,
+        history: 'single',
+        run: ({ sceneApi }) => {
+            sceneApi.update(node.id, { pipeMaterial });
+            return { selectedIds: [node.id] };
+        },
+    }));
+    return variants;
+}

package/dist/shared/mep-presets.d.ts

@@ -0,0 +1,11 @@
+import type { PipeSegmentNode } from '@pascal-app/core';
+export type PipePreset = {
+    id: string;
+    label: string;
+    system: PipeSegmentNode['system'];
+    pipeMaterial: PipeSegmentNode['pipeMaterial'];
+    diameter: number;
+    sloped: boolean;
+};
+export declare const PIPE_PRESETS: readonly PipePreset[];
+//# sourceMappingURL=mep-presets.d.ts.map

package/dist/shared/mep-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mep-presets.d.ts","sourceRoot":"","sources":["../../src/shared/mep-presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IACjC,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IAC7C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAiC7C,CAAA"}

package/dist/shared/mep-presets.js

@@ -0,0 +1,34 @@
+export const PIPE_PRESETS = [
+    {
+        id: 'pvc-waste',
+        label: 'Waste · PVC · sloped',
+        system: 'waste',
+        pipeMaterial: 'pvc',
+        diameter: 2,
+        sloped: true,
+    },
+    {
+        id: 'abs-waste',
+        label: 'Waste · ABS · sloped',
+        system: 'waste',
+        pipeMaterial: 'abs',
+        diameter: 2,
+        sloped: true,
+    },
+    {
+        id: 'cast-iron-waste',
+        label: 'Waste · cast iron · sloped',
+        system: 'waste',
+        pipeMaterial: 'cast-iron',
+        diameter: 3,
+        sloped: true,
+    },
+    {
+        id: 'pvc-vent',
+        label: 'Vent · PVC · level',
+        system: 'vent',
+        pipeMaterial: 'pvc',
+        diameter: 2,
+        sloped: false,
+    },
+];

package/dist/shared/node-batch/candidates.d.ts

@@ -0,0 +1,29 @@
+import type { BatchCandidate } from './types';
+/**
+ * Candidate collection + source hide/reveal for node batching. Counterpart of
+ * the wall batch's `toCandidate` (../../wall/wall-batch-system.tsx), walking
+ * each node's mounted subtree instead of a single wall mesh.
+ */
+/** Kinds the batch system manages. Walls keep their merged-geometry batch. */
+export declare const BATCH_KINDS: ReadonlySet<string>;
+export declare function collectBatchCandidate(nodeId: string): BatchCandidate | null;
+export declare function hideBatchedNode(candidate: BatchCandidate): void;
+/**
+ * Belt-and-braces reveal: drops the 'batched' hold from EVERY mesh under
+ * every level root. Per-node reveals track the meshes they hid, but a system
+ * can rebuild a node's children while it is batched (swapping the tracked
+ * refs), and a stale ref means a mesh stays off the scene layer — which the
+ * GLB exporter prunes. `showInScene` is a no-op on unheld meshes, so the
+ * sweep is safe; it runs only on the rare release-everything paths (capture,
+ * appearance switches, isolation).
+ */
+export declare function revealAllBatchedHolds(): void;
+export declare function revealBatchedNode(nodeId: string): void;
+/**
+ * Nodes the viewer is lighting up — plus hosted openings whose host wall is
+ * lit or mid-gesture: a dragged wall carries its doors with it through live
+ * overrides, and a batched copy would stay behind until commit.
+ */
+export declare function collectTintedNodes(nodeIds: ReadonlySet<string>): Set<string>;
+export declare function getBatchableNodeIds(): ReadonlySet<string>;
+//# sourceMappingURL=candidates.d.ts.map

package/dist/shared/node-batch/candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../../src/shared/node-batch/candidates.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AAEzD;;;;GAIG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,CAO1C,CAAA;AA2EF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAqF3E;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAI/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAQ5C;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKtD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAyB5E;AAED,wBAAgB,mBAAmB,IAAI,WAAW,CAAC,MAAM,CAAC,CAOzD"}

package/dist/shared/node-batch/candidates.js

@@ -0,0 +1,260 @@
+import { itemClipRegistry, sceneRegistry, useInteractive, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { hideFromScene, SCENE_LAYER, showInScene, useViewer } from '@pascal-app/viewer';
+import { Matrix4 } from 'three';
+import { isSlotPaintPreviewActive } from '../slot-paint';
+/**
+ * Candidate collection + source hide/reveal for node batching. Counterpart of
+ * the wall batch's `toCandidate` (../../wall/wall-batch-system.tsx), walking
+ * each node's mounted subtree instead of a single wall mesh.
+ */
+/** Kinds the batch system manages. Walls keep their merged-geometry batch. */
+export const BATCH_KINDS = new Set([
+    'item',
+    'column',
+    'door',
+    'window',
+    'ceiling',
+    'slab',
+]);
+const rootInverse = new Matrix4();
+/** Source meshes currently draw-hidden per node, so reveal needs no candidate. */
+const hiddenMeshesByNode = new Map();
+/**
+ * Batchable meshes of one subtree. Recurses manually and cuts at the first
+ * invisible node — `traverse` would descend into hidden branches (a toggled-off
+ * variant, a cutout group) — and at any HOSTED child node's registered group:
+ * an item can host other items (a shelf's books), whose groups mount inside
+ * the host's. Packing those would freeze the child at the host's join pose
+ * with no release of its own (it is not a store member).
+ */
+function collectMeshes(object, out, hostedRoots) {
+    if (object.visible === false || hostedRoots.has(object))
+        return;
+    const mesh = object;
+    if (mesh.isMesh &&
+        mesh.name !== 'cutout' &&
+        mesh.name !== 'ceiling-grid' &&
+        mesh.layers.isEnabled(SCENE_LAYER)) {
+        out.push(mesh);
+    }
+    for (const child of object.children)
+        collectMeshes(child, out, hostedRoots);
+}
+/**
+ * The level this node's batches live under, or null when the node is not in
+ * batchable scope. Items, columns, ceilings and slabs qualify directly under a level;
+ * doors and windows through a wall that is itself parented to a level. Other
+ * hosting shapes (roof faces, blocks, wall-hosted items) move when their host
+ * changes without any signal the batch would see — they draw themselves.
+ */
+function resolveLevelId(node, nodes) {
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    if (!parent)
+        return null;
+    if (node.type === 'item' ||
+        node.type === 'column' ||
+        node.type === 'ceiling' ||
+        node.type === 'slab') {
+        return parent.type === 'level' ? parent.id : null;
+    }
+    // door / window: host wall → its level. A hidden wall hides its openings
+    // through group visibility — batch instances hang off the level root and
+    // would keep drawing them.
+    if (parent.type !== 'wall' || parent.visible === false)
+        return null;
+    const level = parent.parentId ? nodes[parent.parentId] : undefined;
+    return level?.type === 'level' ? level.id : null;
+}
+function isExcluded(node) {
+    if (node.type === 'item') {
+        const asset = node.asset;
+        if (asset?.interactive)
+            return true;
+        // A registered clip means the item animates its own subtree (a fan's
+        // spin) — per-mesh transforms move under a static batch instance.
+        if (itemClipRegistry.has(node.id))
+            return true;
+        return false;
+    }
+    if (node.type === 'door') {
+        // Mid-swing doors rebuild per tick off their animation record; the
+        // completion dirty mark re-joins them at the settled pose.
+        return node.id in useInteractive.getState().doorAnimations;
+    }
+    if (node.type === 'window') {
+        return node.id in useInteractive.getState().windowAnimations;
+    }
+    return false;
+}
+export function collectBatchCandidate(nodeId) {
+    const nodes = useScene.getState().nodes;
+    const node = nodes[nodeId];
+    if (!node || !BATCH_KINDS.has(node.type) || node.visible === false)
+        return null;
+    const levelId = resolveLevelId(node, nodes);
+    if (!levelId)
+        return null;
+    if (isExcluded(node) || isSlotPaintPreviewActive(nodeId))
+        return null;
+    const group = sceneRegistry.nodes.get(nodeId);
+    if (!group)
+        return null;
+    // Items hold their dirty mark until the GLB settles; other kinds mount
+    // their real geometry synchronously and carry no such flag. A GLB that
+    // ships clips autoplays its first one even without an interactive effect
+    // (ItemAnimation's no-effect fallback) — static batching would freeze it.
+    if (node.type === 'item') {
+        const userData = group.userData;
+        if (userData.itemModelSettled !== true)
+            return null;
+        if (userData.itemHasAnimations === true)
+            return null;
+    }
+    // A live override on the node (or, for hosted openings, on the host wall)
+    // means an in-flight gesture: transforms are moving under our feet and the
+    // commit's dirty mark has not landed yet.
+    const overrides = useLiveNodeOverrides.getState();
+    if (overrides.get(nodeId) || useLiveTransforms.getState().get(nodeId))
+        return null;
+    if ((node.type === 'door' || node.type === 'window') &&
+        node.parentId &&
+        overrides.get(node.parentId)) {
+        return null;
+    }
+    const levelRoot = sceneRegistry.nodes.get(levelId);
+    if (!levelRoot)
+        return null;
+    const hostedRoots = new Set();
+    const children = node.children;
+    if (Array.isArray(children)) {
+        for (const childId of children) {
+            const childGroup = sceneRegistry.nodes.get(String(childId));
+            if (childGroup)
+                hostedRoots.add(childGroup);
+        }
+    }
+    const meshes = [];
+    collectMeshes(group, meshes, hostedRoots);
+    if (meshes.length === 0)
+        return null;
+    levelRoot.updateWorldMatrix(true, false);
+    rootInverse.copy(levelRoot.matrixWorld).invert();
+    const entries = [];
+    for (const [meshIndex, mesh] of meshes.entries()) {
+        const material = mesh.material;
+        // Array materials draw per geometry group — a shape BatchedMesh cannot
+        // hold; transparent ones depend on per-object blend ordering (door/window
+        // glass keeps its own draw); `material.visible === false` is the
+        // selection-hitbox idiom — hitboxes must stay pickable sources, never
+        // batch geometry.
+        if (Array.isArray(material))
+            continue;
+        if (!material || material.transparent === true || material.visible === false)
+            continue;
+        if (!mesh.geometry?.getAttribute('position'))
+            continue;
+        mesh.updateWorldMatrix(true, false);
+        entries.push({
+            nodeId,
+            levelId,
+            allocationKey: node.type === 'ceiling' || node.type === 'slab' ? `${nodeId}:${meshIndex}` : undefined,
+            mesh,
+            geometry: mesh.geometry,
+            material,
+            castShadow: mesh.castShadow,
+            receiveShadow: mesh.receiveShadow,
+            matrixInLevel: new Matrix4().multiplyMatrices(rootInverse, mesh.matrixWorld),
+        });
+    }
+    if (entries.length === 0)
+        return null;
+    return { nodeId, levelId, entries };
+}
+export function hideBatchedNode(candidate) {
+    const meshes = candidate.entries.map((entry) => entry.mesh);
+    for (const mesh of meshes)
+        hideFromScene(mesh, 'batched');
+    hiddenMeshesByNode.set(candidate.nodeId, meshes);
+}
+/**
+ * Belt-and-braces reveal: drops the 'batched' hold from EVERY mesh under
+ * every level root. Per-node reveals track the meshes they hid, but a system
+ * can rebuild a node's children while it is batched (swapping the tracked
+ * refs), and a stale ref means a mesh stays off the scene layer — which the
+ * GLB exporter prunes. `showInScene` is a no-op on unheld meshes, so the
+ * sweep is safe; it runs only on the rare release-everything paths (capture,
+ * appearance switches, isolation).
+ */
+export function revealAllBatchedHolds() {
+    for (const levelId of sceneRegistry.byType.level ?? []) {
+        const root = sceneRegistry.nodes.get(levelId);
+        root?.traverse((child) => {
+            if (child.isMesh)
+                showInScene(child, 'batched');
+        });
+    }
+    hiddenMeshesByNode.clear();
+}
+export function revealBatchedNode(nodeId) {
+    const meshes = hiddenMeshesByNode.get(nodeId);
+    if (!meshes)
+        return;
+    for (const mesh of meshes)
+        showInScene(mesh, 'batched');
+    hiddenMeshesByNode.delete(nodeId);
+}
+/**
+ * Nodes the viewer is lighting up — plus hosted openings whose host wall is
+ * lit or mid-gesture: a dragged wall carries its doors with it through live
+ * overrides, and a batched copy would stay behind until commit.
+ */
+export function collectTintedNodes(nodeIds) {
+    const viewer = useViewer.getState();
+    const tinted = new Set();
+    for (const id of viewer.selection.selectedIds)
+        if (nodeIds.has(id))
+            tinted.add(id);
+    for (const id of viewer.previewSelectedIds)
+        if (nodeIds.has(id))
+            tinted.add(id);
+    for (const id of viewer.externalSelectedIds)
+        if (nodeIds.has(id))
+            tinted.add(id);
+    const hovered = viewer.hoveredId;
+    if (hovered && nodeIds.has(hovered))
+        tinted.add(hovered);
+    const nodes = useScene.getState().nodes;
+    const overrides = useLiveNodeOverrides.getState();
+    const wallLit = new Set();
+    for (const id of viewer.selection.selectedIds)
+        wallLit.add(id);
+    for (const id of viewer.previewSelectedIds)
+        wallLit.add(id);
+    for (const id of viewer.externalSelectedIds)
+        wallLit.add(id);
+    if (hovered)
+        wallLit.add(hovered);
+    for (const id of nodeIds) {
+        if (tinted.has(id))
+            continue;
+        const node = nodes[id];
+        if (!node || (node.type !== 'door' && node.type !== 'window'))
+            continue;
+        const wallId = node.parentId;
+        if (!wallId)
+            continue;
+        if (wallLit.has(wallId) || overrides.get(wallId))
+            tinted.add(id);
+    }
+    return tinted;
+}
+export function getBatchableNodeIds() {
+    const out = new Set();
+    for (const kind of BATCH_KINDS) {
+        const ids = sceneRegistry.byType[kind];
+        if (ids)
+            for (const id of ids)
+                out.add(id);
+    }
+    return out;
+}

package/dist/shared/node-batch/store.d.ts

@@ -0,0 +1,26 @@
+import { type BatchCandidate, type BatchEntry, type GetLevelRoot, type NodeBatchStats, type NodeBatchStoreApi } from './types';
+export declare class NodeBatchStore implements NodeBatchStoreApi {
+    private readonly getLevelRoot;
+    private readonly batches;
+    private readonly keysByNode;
+    private readonly instancesByNode;
+    private readonly pending;
+    private instanceCount;
+    private readonly counters;
+    constructor(getLevelRoot: GetLevelRoot);
+    join(candidates: BatchCandidate[], minEntriesForNewBatch: number): BatchEntry[];
+    private requiredSpace;
+    private addEntry;
+    release(nodeId: string): boolean;
+    flushReleases(now?: number): void;
+    pruneEmpty(now?: number, retainedLevels?: ReadonlySet<string>, earliestDisposalAt?: number): boolean;
+    pruneDetached(): Set<string>;
+    has(nodeId: string): boolean;
+    nodeIds(): ReadonlySet<string>;
+    disposeLevel(levelId: string): void;
+    disposeAll(): void;
+    stats(): NodeBatchStats;
+    private createBatch;
+    private disposeBatch;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/shared/node-batch/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/shared/node-batch/store.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,YAAY,EAEjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,SAAS,CAAA;AA8DhB,qBAAa,cAAe,YAAW,iBAAiB;IAiB1C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAhBzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAC5D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAG7B;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAMxB;gBAE4B,YAAY,EAAE,YAAY;IAEvD,IAAI,CAAC,UAAU,EAAE,cAAc,EAAE,EAAE,qBAAqB,EAAE,MAAM,GAAG,UAAU,EAAE;IAyE/E,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,QAAQ;IAoDhB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAqBhC,aAAa,CAAC,GAAG,SAAoB,GAAG,IAAI;IAS5C,UAAU,CACR,GAAG,SAAoB,EACvB,cAAc,GAAE,WAAW,CAAC,MAAM,CAAa,EAC/C,kBAAkB,SAAI,GACrB,OAAO;IAeV,aAAa,IAAI,GAAG,CAAC,MAAM,CAAC;IAc5B,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAG5B,OAAO,IAAI,WAAW,CAAC,MAAM,CAAC;IAG9B,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQnC,UAAU,IAAI,IAAI;IAOlB,KAAK,IAAI,cAAc;IASvB,OAAO,CAAC,WAAW;IAkDnB,OAAO,CAAC,YAAY;CAMrB"}