@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/fence-feature/definition.js

@@ -0,0 +1,116 @@
+import { FenceGateNode, FenceOpeningNode, findLevelAncestorId, } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { AnimationClip, QuaternionKeyframeTrack } from 'three';
+import { buildFenceFeatureFloorplan } from './floorplan.js';
+import { fenceFeatureAffordance } from './floorplan-affordances.js';
+import { buildFenceFeatureGeometry } from './geometry.js';
+import { fenceFeatureHandles } from './handles.js';
+import { FenceFeatureEditor } from './inspector.js';
+import { toggleFenceGate } from './interaction.js';
+import { createFenceFeatureMoveSession } from './move-session.js';
+const floorplanMoveTarget = ({ node, sceneApi }) => {
+    if (!sceneApi)
+        throw new Error('Fence feature move requires SceneApi');
+    const levelId = findLevelAncestorId(node.id, sceneApi.nodes()) ?? null;
+    const session = createFenceFeatureMoveSession(node, sceneApi, levelId, (id) => useViewer.getState().setSelection({ selectedIds: [id] }));
+    return {
+        affectedIds: session.affectedIds,
+        apply: ({ planPoint }) => session.update(planPoint),
+        canCommit: session.canCommit,
+        commit: session.commit,
+    };
+};
+const parametrics = {
+    groups: [
+        {
+            label: 'Settings',
+            fields: [{ key: 'center', kind: 'custom', component: FenceFeatureEditor }],
+        },
+    ],
+};
+const shared = {
+    schemaVersion: 1,
+    category: 'structure',
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+    },
+    geometry: buildFenceFeatureGeometry,
+    floorplan: buildFenceFeatureFloorplan,
+    floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
+    floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
+    handles: fenceFeatureHandles,
+    floorplanMoveTarget,
+    affordanceTools: { move: () => import('./move-tool.js') },
+    affordanceHints: {
+        move: [
+            { key: 'Left click', label: 'Place on a fence' },
+            { key: 'Esc', label: 'Cancel move' },
+        ],
+    },
+    parametrics,
+};
+export const fenceGateDefinition = {
+    ...shared,
+    kind: 'fence-gate',
+    keyboardActions: {
+        e: {
+            appliesTo: (node) => node.type === 'fence-gate',
+            run: (node) => toggleFenceGate(node.id),
+        },
+    },
+    schema: FenceGateNode,
+    extensions: {
+        'pascal:editor/floorplan': {
+            actionMenu: { actions: () => import('./actions.js') },
+        },
+    },
+    exportAnimation: ({ node, object }) => node.type === 'fence-gate' ? bakeFenceGateClip(node.id, object) : null,
+    defaults: () => {
+        const { id, type, ...rest } = FenceGateNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Gate',
+        description: 'A gate hosted by a fence.',
+        icon: { kind: 'url', src: '/icons/fence.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};
+function bakeFenceGateClip(id, object) {
+    const tracks = [];
+    object.traverse((part) => {
+        const marker = part.userData.pascalFenceGateLeaf;
+        if (typeof marker?.openRotationY !== 'number' || Math.abs(marker.openRotationY) < 1e-5)
+            return;
+        part.rotation.y = 0;
+        const closed = part.quaternion.clone();
+        part.rotation.y = marker.openRotationY;
+        const open = part.quaternion.clone();
+        part.rotation.y = 0;
+        tracks.push(new QuaternionKeyframeTrack(`${part.uuid}.quaternion`, [0, 1], [...closed.toArray(), ...open.toArray()]));
+    });
+    if (tracks.length === 0)
+        return null;
+    const clip = new AnimationClip(`${id}: open`, 1, tracks);
+    clip.userData = { loop: false };
+    return clip;
+}
+export const fenceOpeningDefinition = {
+    ...shared,
+    kind: 'fence-opening',
+    schema: FenceOpeningNode,
+    defaults: () => {
+        const { id, type, ...rest } = FenceOpeningNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Open Passage',
+        description: 'An intentional opening in a fence.',
+        icon: { kind: 'url', src: '/icons/door.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};

package/dist/fence-feature/floorplan-affordances.d.ts

@@ -0,0 +1,3 @@
+import { type FenceFeatureNode, type FloorplanAffordance } from '@pascal-app/core';
+export declare const fenceFeatureAffordance: FloorplanAffordance<FenceFeatureNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/fence-feature/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence-feature/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,gBAAgB,CAmCxE,CAAA"}

package/dist/fence-feature/floorplan-affordances.js

@@ -0,0 +1,37 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, projectPointToFence, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+export const fenceFeatureAffordance = {
+    start({ node, payload, nodes }) {
+        const host = node.parentId ? nodes[node.parentId] : undefined;
+        const edge = payload.edge;
+        let patch = {};
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                if (host?.type !== 'fence')
+                    return;
+                const distance = projectPointToFence(host, planPoint).center;
+                let center = distance;
+                let width = node.width;
+                if (edge !== 'center') {
+                    const fixed = node.center + ((edge === 'start' ? 1 : -1) * node.width) / 2;
+                    if (edge === 'start' ? distance > fixed - 0.35 : distance < fixed + 0.35)
+                        return;
+                    width = Math.abs(fixed - distance);
+                    center = (fixed + distance) / 2;
+                }
+                const fence = fenceWithFeatures(host, (host.children ?? []).map((id) => nodes[id]).filter(Boolean));
+                if (!canPlaceFenceFeature(fence, { ...fenceFeatureData(node), center, width }))
+                    return;
+                patch = { center, width };
+                useLiveNodeOverrides.getState().set(node.id, patch);
+                useScene.getState().markDirty(node.id);
+                useScene.getState().markDirty(host.id);
+            },
+            canCommit: () => Object.keys(patch).length > 0,
+            commit() {
+                useScene.getState().updateNode(node.id, patch);
+                useLiveNodeOverrides.getState().clear(node.id);
+            },
+        };
+    },
+};

package/dist/fence-feature/floorplan.d.ts

@@ -0,0 +1,4 @@
+import { type FenceFeatureData, type FenceFeatureNode, type FenceNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export declare function buildFenceFeatureFloorplan(child: FenceFeatureNode, ctx: GeometryContext): FloorplanGeometry | null;
+export declare function buildFenceFeatureSymbol(data: FenceFeatureData, node: FenceNode, ctx: GeometryContext, interactive?: boolean): FloorplanGeometry;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/fence-feature/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence-feature/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAI1B;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,SAAS,EACf,GAAG,EAAE,eAAe,EACpB,WAAW,UAAO,GACjB,iBAAiB,CAiHnB"}

package/dist/fence-feature/floorplan.js

@@ -0,0 +1,120 @@
+import { fenceFeatureData, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceGateLeaves, } from '@pascal-app/core';
+export function buildFenceFeatureFloorplan(child, ctx) {
+    const node = ctx.parent;
+    if (node?.type !== 'fence')
+        return null;
+    return buildFenceFeatureSymbol(fenceFeatureData(child), node, ctx);
+}
+export function buildFenceFeatureSymbol(data, node, ctx, interactive = true) {
+    const length = Math.max(getFenceCenterlineLength(node), 0.001);
+    const feature = {
+        ...data,
+        startT: (data.center - data.width / 2) / length,
+        endT: (data.center + data.width / 2) / length,
+        centerT: data.center / length,
+    };
+    const features = [feature];
+    const isSelected = interactive && (ctx.viewState?.selected ?? false);
+    const accentStroke = isSelected
+        ? (ctx.viewState?.palette?.selectedStroke ?? '#8381ed')
+        : ctx.viewState?.hovered
+            ? '#8381ed'
+            : '#111827';
+    const markerSurface = '#ffffff';
+    const children = [];
+    for (const feature of features) {
+        const start = getFenceCenterlineFrameAt(node, feature.startT).point;
+        const end = getFenceCenterlineFrameAt(node, feature.endT).point;
+        if (feature.showPosts !== false)
+            for (const point of [start, end]) {
+                children.push({
+                    kind: 'circle',
+                    cx: point.x,
+                    cy: point.y,
+                    r: Math.max(node.postSize / 2, 0.04),
+                    fill: markerSurface,
+                    stroke: accentStroke,
+                    strokeWidth: 1.5,
+                    vectorEffect: 'non-scaling-stroke',
+                });
+            }
+        if (feature.kind === 'gate') {
+            for (const leaf of getFenceGateLeaves(node, feature)) {
+                children.push({
+                    kind: 'line',
+                    x1: leaf.hinge.x,
+                    y1: leaf.hinge.y,
+                    x2: leaf.end.x,
+                    y2: leaf.end.y,
+                    stroke: accentStroke,
+                    strokeWidth: 3,
+                    vectorEffect: 'non-scaling-stroke',
+                });
+                children.push({
+                    kind: 'hit-line',
+                    x1: leaf.hinge.x,
+                    y1: leaf.hinge.y,
+                    x2: leaf.end.x,
+                    y2: leaf.end.y,
+                    strokeWidthPx: 16,
+                    cursor: 'pointer',
+                });
+                const angle = leaf.rotation - leaf.closedAngle;
+                if (Math.abs(angle) > 0.001) {
+                    const x = leaf.hinge.x + Math.cos(leaf.closedAngle) * leaf.width;
+                    const y = leaf.hinge.y + Math.sin(leaf.closedAngle) * leaf.width;
+                    children.push({
+                        kind: 'path',
+                        d: `M ${x} ${y} A ${leaf.width} ${leaf.width} 0 0 ${angle > 0 ? 1 : 0} ${leaf.end.x} ${leaf.end.y}`,
+                        fill: 'none',
+                        stroke: accentStroke,
+                        strokeWidth: 1,
+                        strokeDasharray: '4 3',
+                        vectorEffect: 'non-scaling-stroke',
+                    });
+                }
+            }
+        }
+        if (isSelected) {
+            for (const [edge, point] of [
+                ['start', start],
+                ['center', getFenceCenterlineFrameAt(node, feature.centerT).point],
+                ['end', end],
+            ]) {
+                children.push({
+                    kind: 'endpoint-handle',
+                    point: [point.x, point.y],
+                    state: 'idle',
+                    variant: 'curve',
+                    affordance: 'move-feature',
+                    payload: { edge },
+                });
+            }
+        }
+    }
+    if (data.kind === 'opening') {
+        const a = getFenceCenterlineFrameAt(node, feature.startT).point;
+        const b = getFenceCenterlineFrameAt(node, feature.endT).point;
+        children.push({
+            kind: 'line',
+            x1: a.x,
+            y1: a.y,
+            x2: b.x,
+            y2: b.y,
+            stroke: accentStroke,
+            strokeWidth: 1.5,
+            strokeDasharray: '4 3',
+            vectorEffect: 'non-scaling-stroke',
+        });
+        children.push({
+            kind: 'hit-line',
+            x1: a.x,
+            y1: a.y,
+            x2: b.x,
+            y2: b.y,
+            strokeWidthPx: 18,
+            cursor: 'pointer',
+        });
+    }
+    return { kind: 'group', children };
+}

package/dist/fence-feature/geometry.d.ts

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode, type GeometryContext } from '@pascal-app/core';
+import type { ColorPreset, RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+export declare function buildFenceFeatureGeometry(node: FenceFeatureNode, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/fence-feature/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence-feature/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,EAA2B,KAAK,EAA2B,MAAM,OAAO,CAAA;AAI/E,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,gBAAgB,EACtB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA4DP"}

package/dist/fence-feature/geometry.js

@@ -0,0 +1,43 @@
+import { fenceFeatureData, getFenceCenterlineFrameAt, getFenceCenterlineLength, getFenceGateLeaves, } from '@pascal-app/core';
+import { BoxGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial } from 'three';
+import { buildFenceGeometry } from '../fence/geometry.js';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
+export function buildFenceFeatureGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const host = ctx?.parent;
+    if (host?.type !== 'fence')
+        return new Group();
+    const group = buildFenceGeometry({ ...host, features: [fenceFeatureData(node)] }, ctx, shading, textures, colorPreset, sceneTheme, 'features');
+    const length = Math.max(getFenceCenterlineLength(host), 0.001);
+    const feature = {
+        ...fenceFeatureData(node),
+        startT: (node.center - node.width / 2) / length,
+        endT: (node.center + node.width / 2) / length,
+        centerT: node.center / length,
+    };
+    const a = getFenceCenterlineFrameAt(host, feature.startT).point;
+    const b = getFenceCenterlineFrameAt(host, feature.endT).point;
+    const followsSurface = (host.path?.length ?? 0) >= 2 || Math.abs(host.curveOffset ?? 0) > 1e-4;
+    const selectedHost = host.surfaceMode === 'selected'
+        ? (host.supportSurfaceNodeId ?? host.supportSlabId)
+        : undefined;
+    const relativeHeight = (x, z) => followsSurface && host.surfaceMode !== 'level'
+        ? (ctx?.supportHeightAt?.(x, z, selectedHost) ?? 0) -
+            (ctx?.supportHeightAt?.(...host.start, selectedHost) ?? 0)
+        : 0;
+    const support = Math.max(relativeHeight(a.x, a.y), relativeHeight(b.x, b.y));
+    const dimensions = getFenceFeatureDimensions(host, fenceFeatureData(node));
+    const bottom = Math.min(dimensions.bottom, dimensions.postBottom);
+    const height = Math.max(dimensions.bottom + dimensions.height, dimensions.postBottom + dimensions.postHeight) -
+        bottom;
+    const spans = node.type === 'fence-gate'
+        ? getFenceGateLeaves(host, feature).map((leaf) => ({ a: leaf.hinge, b: leaf.end }))
+        : [{ a, b }];
+    for (const span of spans) {
+        const pick = new Mesh(new BoxGeometry(Math.hypot(span.b.x - span.a.x, span.b.y - span.a.y), height, Math.max(host.thickness, 0.12)), new MeshBasicMaterial({ visible: false, side: DoubleSide }));
+        pick.position.set((span.a.x + span.b.x) / 2, support + bottom + height / 2, (span.a.y + span.b.y) / 2);
+        pick.rotation.y = -Math.atan2(span.b.y - span.a.y, span.b.x - span.a.x);
+        pick.userData.pascalExport = 'strip';
+        group.children[0]?.add(pick);
+    }
+    return group;
+}

package/dist/fence-feature/handles.d.ts

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode, type FenceNode, type HandleDescriptor, type SceneApi } from '@pascal-app/core';
+export declare function featureHost(node: FenceFeatureNode, scene: SceneApi): FenceNode | undefined;
+export declare function featurePatch(node: FenceFeatureNode, patch: Partial<FenceFeatureNode>, scene: SceneApi): Partial<FenceFeatureNode>;
+export declare function fenceFeatureHandles(node: FenceFeatureNode, scene?: SceneApi): HandleDescriptor<FenceFeatureNode>[];
+//# sourceMappingURL=handles.d.ts.map

package/dist/fence-feature/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../src/fence-feature/handles.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EAKd,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,WAAW,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CAG1F;AACD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAChC,KAAK,EAAE,QAAQ,GACd,OAAO,CAAC,gBAAgB,CAAC,CAY3B;AACD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,gBAAgB,EACtB,KAAK,CAAC,EAAE,QAAQ,GACf,gBAAgB,CAAC,gBAAgB,CAAC,EAAE,CAiEtC"}

package/dist/fence-feature/handles.js

@@ -0,0 +1,84 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, getFenceCenterlineFrameAt, getFenceCenterlineLength, projectPointToFence, } from '@pascal-app/core';
+import { fenceBaseElevation } from '../fence/definition.js';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
+export function featureHost(node, scene) {
+    const parent = node.parentId ? scene.get(node.parentId) : undefined;
+    return parent?.type === 'fence' ? parent : undefined;
+}
+export function featurePatch(node, patch, scene) {
+    const host = featureHost(node, scene);
+    if (!host)
+        return {};
+    const fence = fenceWithFeatures(host, (host.children ?? [])
+        .map((id) => scene.get(id))
+        .filter((n) => !!n));
+    return canPlaceFenceFeature(fence, fenceFeatureData({ ...node, ...patch }))
+        ? patch
+        : {};
+}
+export function fenceFeatureHandles(node, scene) {
+    if (!scene)
+        return [];
+    const host = featureHost(node, scene);
+    if (!host)
+        return [];
+    const frame = (n) => getFenceCenterlineFrameAt(host, n.center / Math.max(getFenceCenterlineLength(host), 0.001));
+    const dimensions = (n) => getFenceFeatureDimensions(host, fenceFeatureData(n));
+    const height = (n) => dimensions(n).height;
+    const base = (n) => {
+        const p = frame(n).point;
+        return fenceBaseElevation(host, scene, [p.x, p.y]);
+    };
+    const handles = [
+        {
+            kind: 'translate',
+            placement: {
+                position: (n) => {
+                    const p = frame(n).point;
+                    return [p.x, base(n) + height(n) / 2, p.y];
+                },
+            },
+            apply: (n, point, api) => featurePatch(n, { center: projectPointToFence(host, [point[0], point[2]]).center }, api),
+        },
+        {
+            kind: 'linear-resize',
+            axis: 'x',
+            dragAxis: (n) => {
+                const tangent = frame(n).tangent;
+                return [tangent.x, 0, tangent.y];
+            },
+            anchor: 'center',
+            min: 0.35,
+            currentValue: (n) => n.width,
+            apply: (n, width, api) => featurePatch(n, { width }, api),
+            placement: {
+                position: (n) => {
+                    const f = frame(n);
+                    const d = n.width / 2 + 0.2;
+                    return [f.point.x + f.tangent.x * d, base(n) + 0.5, f.point.y + f.tangent.y * d];
+                },
+                rotationY: (n) => -Math.atan2(frame(n).tangent.y, frame(n).tangent.x),
+            },
+        },
+    ];
+    handles.push({
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: 0.3,
+        max: 6,
+        currentValue: height,
+        apply: (n, value) => ({
+            height: value,
+            matchFenceHeight: false,
+            ...(n.type === 'fence-gate' ? { clearance: dimensions(n).bottom } : {}),
+        }),
+        placement: {
+            position: (n) => {
+                const p = frame(n).point;
+                return [p.x, base(n) + height(n) + dimensions(n).bottom + 0.35, p.y];
+            },
+        },
+    });
+    return handles;
+}

package/dist/fence-feature/inspector.d.ts

@@ -0,0 +1,6 @@
+import { type FenceFeatureNode } from '@pascal-app/core';
+export declare function FenceFeatureEditor({ node: child, onUpdate, }: {
+    node: FenceFeatureNode;
+    onUpdate: (patch: Partial<FenceFeatureNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=inspector.d.ts.map

package/dist/fence-feature/inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../src/fence-feature/inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAMzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EAAE,KAAK,EACX,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CACrD,+BAkTA"}