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

package/dist/block/preview.d.ts

@@ -0,0 +1,6 @@
+import type { BlockNode } from '@pascal-app/core';
+export default function BlockPreview({ node, valid }: {
+    node: BlockNode;
+    valid?: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=preview.d.ts.map

package/dist/block/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/block/preview.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAOjD,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EAAE,IAAI,EAAE,KAAY,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,+BAwChG"}

package/dist/block/preview.js

@@ -0,0 +1,46 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { Color, Mesh } from 'three';
+import { buildBlockGeometry } from './geometry';
+export default function BlockPreview({ node, valid = true }) {
+    const shading = useViewer((state) => state.shading);
+    const textures = useViewer((state) => state.textures);
+    const colorPreset = useViewer((state) => state.colorPreset);
+    const sceneTheme = useViewer((state) => state.sceneTheme);
+    const preview = useMemo(() => {
+        const next = buildBlockGeometry(node, undefined, shading, textures, colorPreset, sceneTheme);
+        const ownedMaterials = [];
+        next.traverse((child) => {
+            child.layers.set(EDITOR_LAYER);
+            child.raycast = () => { };
+            if (!(child instanceof Mesh))
+                return;
+            const sourceMaterials = Array.isArray(child.material) ? child.material : [child.material];
+            const materials = sourceMaterials.map((material) => material.clone());
+            for (const material of materials) {
+                material.transparent = true;
+                material.opacity = 0.52;
+                material.depthWrite = false;
+                if (!valid && 'color' in material && material.color instanceof Color) {
+                    material.color.set('#ef4444');
+                }
+            }
+            ownedMaterials.push(...materials);
+            child.material = Array.isArray(child.material) ? materials : materials[0];
+        });
+        return { object: next, ownedMaterials };
+    }, [colorPreset, node, sceneTheme, shading, textures, valid]);
+    useEffect(() => () => {
+        preview.object.traverse((child) => {
+            if (!(child instanceof Mesh))
+                return;
+            child.geometry.dispose();
+        });
+        for (const material of preview.ownedMaterials)
+            material.dispose();
+    }, [preview]);
+    return _jsx("primitive", { object: preview.object });
+}

package/dist/block/rotation-drag.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from 'three';
+export declare function signedAngleAroundAxis(from: Vector3, to: Vector3, axis: Vector3): number;
+export declare function lockedRotationAngleFromHits(origin: Vector3, initialHit: Vector3, currentHit: Vector3, axis: Vector3): number | null;
+export declare function unwrapRotationDelta(previous: number, current: number): number;
+//# sourceMappingURL=rotation-drag.d.ts.map

package/dist/block/rotation-drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation-drag.d.ts","sourceRoot":"","sources":["../../src/block/rotation-drag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEpC,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAEvF;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,OAAO,EACnB,UAAU,EAAE,OAAO,EACnB,IAAI,EAAE,OAAO,GACZ,MAAM,GAAG,IAAI,CAKf;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAK7E"}

package/dist/block/rotation-drag.js

@@ -0,0 +1,18 @@
+export function signedAngleAroundAxis(from, to, axis) {
+    return Math.atan2(axis.dot(from.clone().cross(to)), from.dot(to));
+}
+export function lockedRotationAngleFromHits(origin, initialHit, currentHit, axis) {
+    const initialVector = initialHit.clone().sub(origin).projectOnPlane(axis);
+    const currentVector = currentHit.clone().sub(origin).projectOnPlane(axis);
+    if (initialVector.lengthSq() < 1e-6 || currentVector.lengthSq() < 1e-6)
+        return null;
+    return signedAngleAroundAxis(initialVector.normalize(), currentVector.normalize(), axis);
+}
+export function unwrapRotationDelta(previous, current) {
+    let delta = current - previous;
+    if (delta > Math.PI)
+        delta -= Math.PI * 2;
+    if (delta < -Math.PI)
+        delta += Math.PI * 2;
+    return delta;
+}

package/dist/block/schema.d.ts

@@ -0,0 +1,2 @@
+export { BlockNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/block/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/block/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/block/schema.js

@@ -0,0 +1 @@
+export { BlockNode } from '@pascal-app/core';

package/dist/block/selection-geometry.d.ts

@@ -0,0 +1,9 @@
+import type { BlockTopology } from '@pascal-app/core';
+import type { Camera, Object3D } from 'three';
+import { Vector2 } from 'three';
+import { type BlockSelection } from './commands';
+export type BlockPoint = [number, number, number];
+export declare function blockSelectionCentroid(topology: BlockTopology, selection: BlockSelection): BlockPoint | null;
+export declare function blockLocalPointToClient(point: BlockPoint, target: Object3D, camera: Camera, canvas: HTMLCanvasElement): Vector2 | null;
+export declare function blockTopologyClientExtent(topology: BlockTopology, target: Object3D, camera: Camera, canvas: HTMLCanvasElement): number | null;
+//# sourceMappingURL=selection-geometry.d.ts.map

package/dist/block/selection-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-geometry.d.ts","sourceRoot":"","sources":["../../src/block/selection-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAW,MAAM,OAAO,CAAA;AACxC,OAAO,EAAE,KAAK,cAAc,EAA2B,MAAM,YAAY,CAAA;AAEzE,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,cAAc,GACxB,UAAU,GAAG,IAAI,CAWnB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,iBAAiB,GACxB,OAAO,GAAG,IAAI,CAShB;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,iBAAiB,GACxB,MAAM,GAAG,IAAI,CASf"}

package/dist/block/selection-geometry.js

@@ -0,0 +1,31 @@
+import { Vector2, Vector3 } from 'three';
+import { blockSelectionVertexIds } from './commands';
+export function blockSelectionCentroid(topology, selection) {
+    const ids = blockSelectionVertexIds(topology, selection);
+    const positions = topology.vertices
+        .filter((vertex) => ids.has(vertex.id))
+        .map((vertex) => vertex.position);
+    if (positions.length === 0)
+        return null;
+    const total = positions.reduce((sum, point) => [sum[0] + point[0], sum[1] + point[1], sum[2] + point[2]], [0, 0, 0]);
+    return [total[0] / positions.length, total[1] / positions.length, total[2] / positions.length];
+}
+export function blockLocalPointToClient(point, target, camera, canvas) {
+    target.updateWorldMatrix(true, false);
+    const projected = target.localToWorld(new Vector3(...point)).project(camera);
+    if (![projected.x, projected.y, projected.z].every(Number.isFinite))
+        return null;
+    const rect = canvas.getBoundingClientRect();
+    return new Vector2(rect.left + ((projected.x + 1) / 2) * rect.width, rect.top + ((1 - projected.y) / 2) * rect.height);
+}
+export function blockTopologyClientExtent(topology, target, camera, canvas) {
+    const points = topology.vertices
+        .map((vertex) => blockLocalPointToClient(vertex.position, target, camera, canvas))
+        .filter((point) => point !== null);
+    if (points.length === 0)
+        return null;
+    const xs = points.map((point) => point.x);
+    const ys = points.map((point) => point.y);
+    const extent = Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys));
+    return Number.isFinite(extent) && extent > 1e-6 ? extent : null;
+}

package/dist/block/selection-model.d.ts

@@ -0,0 +1,17 @@
+import type { BlockTopology } from '@pascal-app/core';
+export type BlockComponentMode = 'vertex' | 'edge' | 'face';
+export type BlockSelection = {
+    mode: BlockComponentMode;
+    ids: string[];
+};
+export type BlockSelectionState = BlockSelection & {
+    activeId: string | null;
+};
+export declare function blockSelectionChanged(previous: BlockSelectionState, next: BlockSelectionState): boolean;
+export declare function createBlockSelection(mode: BlockComponentMode, ids?: string[]): BlockSelectionState;
+export declare function selectBlockComponent(selection: BlockSelectionState, id: string, additive: boolean): BlockSelectionState;
+export declare function convertBlockSelection(topology: BlockTopology, selection: BlockSelectionState, nextMode: BlockComponentMode): BlockSelectionState;
+export declare function selectAllBlockComponents(topology: BlockTopology, selection: BlockSelectionState): BlockSelectionState;
+export declare function invertBlockSelection(topology: BlockTopology, selection: BlockSelectionState): BlockSelectionState;
+export declare function clearBlockSelection(selection: BlockSelectionState): BlockSelectionState;
+//# sourceMappingURL=selection-model.d.ts.map

package/dist/block/selection-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-model.d.ts","sourceRoot":"","sources":["../../src/block/selection-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAE3D,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,kBAAkB,CAAA;IACxB,GAAG,EAAE,MAAM,EAAE,CAAA;CACd,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG;IACjD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB,CAAA;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,mBAAmB,EAC7B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAOT;AAgCD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,kBAAkB,EACxB,GAAG,GAAE,MAAM,EAAO,GACjB,mBAAmB,CAErB;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,mBAAmB,EAC9B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,OAAO,GAChB,mBAAmB,CAOrB;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,kBAAkB,GAC3B,mBAAmB,CAoBrB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,mBAAmB,GAC7B,mBAAmB,CAGrB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,mBAAmB,GAC7B,mBAAmB,CAIrB;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,mBAAmB,GAAG,mBAAmB,CAEvF"}

package/dist/block/selection-model.js

@@ -0,0 +1,84 @@
+export function blockSelectionChanged(previous, next) {
+    return (previous.mode !== next.mode ||
+        previous.activeId !== next.activeId ||
+        previous.ids.length !== next.ids.length ||
+        previous.ids.some((id, index) => id !== next.ids[index]));
+}
+function idsForMode(topology, mode) {
+    switch (mode) {
+        case 'vertex':
+            return topology.vertices.map((vertex) => vertex.id);
+        case 'edge':
+            return topology.edges.map((edge) => edge.id);
+        case 'face':
+            return topology.faces.map((face) => face.id);
+    }
+}
+function selectedVertexIds(topology, selection) {
+    const selected = new Set(selection.ids);
+    if (selection.mode === 'vertex')
+        return selected;
+    const vertices = new Set();
+    if (selection.mode === 'edge') {
+        for (const edge of topology.edges) {
+            if (!selected.has(edge.id))
+                continue;
+            vertices.add(edge.vertexIds[0]);
+            vertices.add(edge.vertexIds[1]);
+        }
+        return vertices;
+    }
+    for (const face of topology.faces) {
+        if (!selected.has(face.id))
+            continue;
+        for (const vertexId of face.vertexIds)
+            vertices.add(vertexId);
+    }
+    return vertices;
+}
+export function createBlockSelection(mode, ids = []) {
+    return { mode, ids, activeId: ids.at(-1) ?? null };
+}
+export function selectBlockComponent(selection, id, additive) {
+    if (!additive)
+        return { ...selection, ids: [id], activeId: id };
+    if (!selection.ids.includes(id)) {
+        return { ...selection, ids: [...selection.ids, id], activeId: id };
+    }
+    const ids = selection.ids.filter((entry) => entry !== id);
+    return { ...selection, ids, activeId: ids.at(-1) ?? null };
+}
+export function convertBlockSelection(topology, selection, nextMode) {
+    if (selection.mode === nextMode)
+        return selection;
+    const vertices = selectedVertexIds(topology, selection);
+    let ids;
+    switch (nextMode) {
+        case 'vertex':
+            ids = topology.vertices.filter((vertex) => vertices.has(vertex.id)).map((vertex) => vertex.id);
+            break;
+        case 'edge':
+            ids = topology.edges
+                .filter((edge) => vertices.has(edge.vertexIds[0]) && vertices.has(edge.vertexIds[1]))
+                .map((edge) => edge.id);
+            break;
+        case 'face':
+            ids = topology.faces
+                .filter((face) => face.vertexIds.every((vertexId) => vertices.has(vertexId)))
+                .map((face) => face.id);
+            break;
+    }
+    return { mode: nextMode, ids, activeId: ids.at(-1) ?? null };
+}
+export function selectAllBlockComponents(topology, selection) {
+    const ids = idsForMode(topology, selection.mode);
+    return { ...selection, ids, activeId: ids.at(-1) ?? null };
+}
+export function invertBlockSelection(topology, selection) {
+    const selected = new Set(selection.ids);
+    const ids = idsForMode(topology, selection.mode).filter((id) => !selected.has(id));
+    return { ...selection, ids, activeId: ids.at(-1) ?? null };
+}
+export function clearBlockSelection(selection) {
+    return { ...selection, ids: [], activeId: null };
+}

package/dist/block/selection.d.ts

@@ -0,0 +1,4 @@
+import { type SelectionAffordanceProps } from '@pascal-app/editor';
+declare const BlockSelectionAffordance: ({ historyApi, interactionApi, node, readOnly, sceneApi, }: SelectionAffordanceProps) => import("react").JSX.Element | null;
+export default BlockSelectionAffordance;
+//# sourceMappingURL=selection.d.ts.map

package/dist/block/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/block/selection.tsx"],"names":[],"mappings":"AAUA,OAAO,EAUL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAA;AAy0H3B,QAAA,MAAM,wBAAwB,GAAI,2DAM/B,wBAAwB,uCAiC1B,CAAA;AAED,eAAe,wBAAwB,CAAA"}