@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/column/floorplan.js

@@ -1,3 +1,4 @@
+import { scriptImages, } from '@pascal-app/core';
 import { floorplanGeometryMetadata } from '@pascal-app/editor';
 import { collectStructuralGridAxes, resolveStructuralGridReference, } from '../structural-grid/coordination';
 // Offsets for the floor-plan selection arrows. Resize chevrons hug the
@@ -40,17 +41,50 @@ export function buildColumnFloorplan(node, ctx) {
     const showSelectedChrome = isSelected || isHighlighted;
     const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#374151';
     const fill = showSelectedChrome ? '#fed7aa' : '#9ca3af';
-    const children = [
-        {
-            kind: 'polygon',
-            points,
-            fill,
-            stroke,
-            strokeWidth: showSelectedChrome ? 0.03 : 0.02,
-            opacity: 0.92,
-            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
-        },
-    ];
+    // A scripted column draws its floor-plan image the way a catalog item does.
+    const floorPlanUrl = scriptImages(node)?.floorPlan;
+    const body = {
+        kind: 'polygon',
+        points,
+        // Transparent, not none: the body stays the hit target under the image.
+        fill: floorPlanUrl ? 'transparent' : fill,
+        stroke,
+        strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+        opacity: 0.92,
+        metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+    };
+    const children = node.children.length
+        ? [
+            // Occupied columns keep label bounds in the overlay without covering their children.
+            {
+                kind: 'polygon',
+                points,
+                fill: 'none',
+                stroke: 'none',
+                pointerEvents: 'none',
+                metadata: body.metadata,
+            },
+            { ...body, metadata: undefined },
+        ]
+        : [body];
+    if (floorPlanUrl && node.source) {
+        const { min, max } = node.source.manifest.bounds;
+        const [cx, cz] = points
+            .reduce((sum, [x, z]) => [sum[0] + x, sum[1] + z], [0, 0])
+            .map((total) => total / points.length);
+        children.push({
+            kind: 'image',
+            url: floorPlanUrl,
+            center: [cx, cz],
+            width: max[0] - min[0],
+            height: max[2] - min[2],
+            // The footprint turns by R(-rotation); the renderer's SVG rotate is R(+angle).
+            rotation: -node.rotation,
+        });
+        // The selection ring goes back on top of the image.
+        if (showSelectedChrome)
+            children.push({ ...body, fill: 'none', pointerEvents: 'none', metadata: undefined });
+    }
     const { halfX, halfZ } = columnPlanHalfExtents(node);
     const centerMarkHalf = Math.min(0.09, Math.max(0.035, Math.min(halfX, halfZ) * 0.45));
     const centerX = node.position[0];
@@ -141,7 +175,14 @@ export function buildColumnFloorplan(node, ctx) {
                 payload: { dim, planAxis: [planAxisX, planAxisY] },
             });
         };
-        if (node.supportStyle !== 'vertical') {
+        if (node.source) {
+            const params = new Set(node.source.manifest.params.map((spec) => spec.id));
+            if (params.has('width'))
+                emitArrowAlong('width', 'x', node.width / 2 + RESIZE_ARROW_OFFSET);
+            if (params.has('depth'))
+                emitArrowAlong('depth', 'z', node.depth / 2 + RESIZE_ARROW_OFFSET);
+        }
+        else if (node.supportStyle !== 'vertical') {
             // Brace columns — width + depth of the bracing structure. Spread
             // arrows (top + bottom) project to the same XZ in top-view, so
             // we only surface bracing dimensions here. The 3D set still has
@@ -185,6 +226,20 @@ export function buildColumnFloorplan(node, ctx) {
     return { kind: 'group', children };
 }
 export function getColumnFloorplanFootprint(node) {
+    if (node.source) {
+        const cos = Math.cos(node.rotation), sin = Math.sin(node.rotation);
+        const { min, max } = node.source.manifest.bounds;
+        const footprint = [
+            [min[0], min[2]],
+            [max[0], min[2]],
+            [max[0], max[2]],
+            [min[0], max[2]],
+        ];
+        return footprint.map(([x, z]) => [
+            node.position[0] + x * cos + z * sin,
+            node.position[2] - x * sin + z * cos,
+        ]);
+    }
     return getColumnPlanFootprint(node).map((point) => [point.x, point.y]);
 }
 /**
@@ -195,6 +250,8 @@ export function getColumnFloorplanFootprint(node) {
  * arrows clear the splay.
  */
 function columnPlanHalfExtents(column) {
+    if (column.source)
+        return { halfX: column.width / 2, halfZ: column.depth / 2 };
     if (column.supportStyle !== 'vertical') {
         return {
             halfX: Math.max(column.width, column.braceWidth ?? 0, column.braceBottomSpread ?? 0, column.braceTopSpread ?? 0) / 2,

package/dist/column/hosted-resize.d.ts

@@ -0,0 +1,215 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+export declare const columnHostedPolicy: {
+    host: (node: AnyNode) => node is {
+        object: "node";
+        style: "plain" | "faceted" | "fluted" | "lathe-turned" | "dravidian-carved" | "cluster";
+        metadata: Record<string, unknown>;
+        id: `column_${string}`;
+        parentId: string | null;
+        visible: boolean;
+        position: [number, number, number];
+        rotation: number;
+        children: string[];
+        width: number;
+        depth: number;
+        radius: number;
+        height: number;
+        crossSection: "round" | "square" | "rectangular" | "octagonal" | "sixteen-sided";
+        edgeSoftness: number;
+        baseHeight: number;
+        capitalHeight: number;
+        shaftProfile: "straight" | "tapered" | "bulged" | "baluster" | "hourglass";
+        shaftTaper: number;
+        shaftBulge: number;
+        shaftStartScale: number;
+        shaftEndScale: number;
+        shaftSegmentCount: number;
+        shaftTwistStep: number;
+        shaftCornerRadius: number;
+        shaftDetail: "none" | "fluted" | "lathe-turned" | "spiral" | "panelled";
+        baseStyle: "none" | "simple-square" | "round-rings" | "square-plinth" | "stepped-square" | "lotus" | "ribbed-lotus" | "panelled-pedestal";
+        baseWidthScale: number;
+        baseDepthScale: number;
+        baseTierCount: number;
+        baseStepSpread: number;
+        basePlinthHeightRatio: number;
+        baseRoundBandScale: number;
+        baseNeckScale: number;
+        baseRoundBandCount: number;
+        baseRibCount: number;
+        baseCarvingLevel: number;
+        basePanelInset: number;
+        capitalStyle: "none" | "simple" | "simple-slab" | "rounded" | "stepped" | "doric" | "volute" | "ionic-volute" | "leaf-carved" | "corinthian-leaf" | "south-indian-bracket" | "wood-bracket";
+        capitalWidthScale: number;
+        capitalDepthScale: number;
+        capitalTierCount: number;
+        capitalStepSpread: number;
+        capitalBandCount: number;
+        voluteSize: number;
+        voluteCount: number;
+        leafCount: number;
+        leafRows: number;
+        bracketDepth: number;
+        bracketTierCount: number;
+        pendantCount: number;
+        capitalCarvingLevel: number;
+        ringCount: number;
+        ringPlacement: "bottom" | "top" | "ends" | "even";
+        ringThickness: number;
+        ringSpread: number;
+        fluteCount: number;
+        fluteDepth: number;
+        fluteWidth: number;
+        spiralTwist: number;
+        spiralRibCount: number;
+        panelCount: number;
+        panelInsetDepth: number;
+        panelShape: "rectangle" | "arched" | "diamond";
+        latheRingCount: number;
+        latheRingSpacing: "bottom" | "top" | "ends" | "even";
+        carvingLevel: number;
+        carvingPlacement: "base" | "shaft" | "capital" | "all";
+        lowerBandEnabled: boolean;
+        lowerBandHeight: number;
+        lowerBandCarvingLevel: number;
+        dentilCount: number;
+        beadCount: number;
+        supportStyle: "vertical" | "a-frame" | "y-frame" | "v-frame" | "x-brace" | "k-brace" | "single-strut" | "tripod" | "trestle" | "portal-frame" | "box-frame";
+        braceWidth: number;
+        braceDepth: number;
+        braceBottomSpread: number;
+        braceTopSpread: number;
+        bracePlateEnabled: boolean;
+        type: "column";
+        source?: {
+            kind: "script";
+            language: "three" | "bpy";
+            script: string;
+            params: Record<string, string | number | boolean>;
+            artifact: string;
+            manifest: {
+                bounds: {
+                    min: [number, number, number];
+                    max: [number, number, number];
+                };
+                params: {
+                    id: string;
+                    kind: "string" | "number" | "boolean";
+                    default: string | number | boolean;
+                    label?: string | undefined;
+                    min?: number | undefined;
+                    max?: number | undefined;
+                    step?: number | undefined;
+                    unit?: string | undefined;
+                    options?: string[] | undefined;
+                }[];
+                parts: {
+                    id: string;
+                    label?: string | undefined;
+                    type?: string | undefined;
+                    bounds?: {
+                        min: [number, number, number];
+                        max: [number, number, number];
+                    } | undefined;
+                }[];
+                surfaces: {
+                    y: number;
+                    polygon: [number, number][];
+                    part?: string | undefined;
+                }[];
+                slots: {
+                    id: string;
+                    label?: string | undefined;
+                    color?: string | undefined;
+                    roughness?: number | undefined;
+                    metalness?: number | undefined;
+                    transparent?: boolean | undefined;
+                    emissive?: boolean | undefined;
+                }[];
+                anchors: {
+                    id: string;
+                    position: [number, number, number];
+                    normal?: [number, number, number] | undefined;
+                }[];
+                lights: {
+                    id: string;
+                    position: [number, number, number];
+                    color: string;
+                    intensity: number;
+                    distance?: number | undefined;
+                }[];
+                undersides: {
+                    polygon: [number, number][];
+                    plane: [number, number, number, number];
+                    part?: string | undefined;
+                }[];
+                animations: {
+                    name: string;
+                    duration: number;
+                }[];
+                cutout: boolean;
+                collider: boolean;
+                triangles: number;
+                cutters?: {
+                    host: "wall" | "slab" | "ceiling" | "mounted";
+                    polygon: number[][];
+                    minY: number;
+                    maxY: number;
+                }[] | undefined;
+            };
+            meta?: {
+                description?: string | undefined;
+                category?: string | undefined;
+                tags?: string[] | undefined;
+                parent?: string | undefined;
+            } | undefined;
+            images?: {
+                artifact: string;
+                thumbnail: string;
+                floorPlan: string;
+            } | undefined;
+        } | undefined;
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        provenance?: {
+            refs: {
+                id: string;
+                ns?: string | undefined;
+                role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            }[];
+            lineage?: {
+                op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        supportSlabId?: string | undefined;
+    };
+    child: (_node: AnyNode) => boolean;
+};
+export declare function planColumnEdit(id: AnyNodeId, patch: Partial<AnyNode>): import("../shared/hosted-resize").HostedUpdate[] | null;
+//# sourceMappingURL=hosted-resize.d.ts.map

package/dist/column/hosted-resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-resize.d.ts","sourceRoot":"","sources":["../../src/column/hosted-resize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAA4B,MAAM,kBAAkB,CAAA;AAGzF,eAAO,MAAM,kBAAkB;iBAChB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBACL,OAAO;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,2DAMpE"}

package/dist/column/hosted-resize.js

@@ -0,0 +1,9 @@
+import { createSceneApi, useScene } from '@pascal-app/core';
+import { planHostedEdit } from '../shared/hosted-resize';
+export const columnHostedPolicy = {
+    host: (node) => node.type === 'column',
+    child: (_node) => true,
+};
+export function planColumnEdit(id, patch) {
+    return planHostedEdit(createSceneApi(useScene), (scene) => scene.update(id, patch), columnHostedPolicy);
+}

package/dist/column/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/column/panel.tsx"],"names":[],"mappings":"AAgSA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAo1BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/column/panel.tsx"],"names":[],"mappings":"AAoSA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA42BlC"}