@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/paint.js

@@ -1,39 +1,33 @@
-import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
-import { setSurfaceRaycastLayers } from '@pascal-app/viewer';
-import { Raycaster } from 'three';
-import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { buildWallFinishLayout, getCurtainWallConfig, getEffectiveWallFaceMaterial, getWallFaceAtLocalPoint, getWallLevelZones, parseWallPaintRole as parseCoreWallPaintRole, parseMaterialRef, plannedWallIds, planWallPaint, resolveWallFaceChain, resolveWallFinish, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, wallRegionRole, wallRoomFaceRole, wallRoomFinishRole, } from '@pascal-app/core';
+import { getWallFaceBaseAt, getWallFinishData, getWallFinishRefs, hasMaterialsForGroups, setSurfaceRaycastLayers, } from '@pascal-app/viewer';
+import { Raycaster, Vector3, } from 'three';
+import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, resolveSlotPaintMaterialRef, } from '../shared/slot-paint';
+import { swapPreviewMaterial } from '../shared/swap-preview-material';
 const WALL_SLOT_IDS = new Set(Object.keys(WALL_SURFACE_SLOT_DEFAULTS));
-const WALL_ARRAY_SLOT_INDEX = {
-    interior: 1,
-    exterior: 2,
-    lowerInterior: 3,
-    middleInterior: 4,
-    upperInterior: 5,
-    topInterior: 6,
-    lowerExterior: 7,
-    middleExterior: 8,
-    upperExterior: 9,
-    topExterior: 10,
-};
-const WALL_INDEX_SLOT = new Map(Object.entries(WALL_ARRAY_SLOT_INDEX).map(([slotId, index]) => [
-    index,
-    slotId,
-]));
+// A curtain wall paints its frame, glass and solid panels (palette 0..2) instead of faces.
+const CURTAIN_WALL_ROLES = ['curtain-frame', 'curtain-glass', 'curtain-solid'];
+const isCurtainWallRole = (role) => CURTAIN_WALL_ROLES.includes(role);
+const FACE_MATERIAL_INDEX = { a: 1, b: 2 };
+export { wallRegionRole, wallRoomFaceRole, wallRoomFinishRole };
+export function parseWallPaintRole(role) {
+    return parseCoreWallPaintRole(role, (slotId) => WALL_SLOT_IDS.has(slotId) || isCurtainWallRole(slotId));
+}
 const wallSlotRaycaster = new Raycaster();
 setSurfaceRaycastLayers(wallSlotRaycaster.layers);
-function resolveSideFromMaterialIndex(materialIndex) {
-    const slotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
-    if (slotId)
-        return getWallSurfaceSideFromBandSlot(slotId);
-    return null;
-}
 function resolveWallSlotByRay(node, ray) {
     if (!ray)
         return null;
     const root = sceneRegistry.nodes.get(node.id);
     if (!root)
         return null;
+    // A mesh caught between a rebuild and its new palette cannot be raycast (three
+    // reads each group's material); no trim answers from it this move.
+    let drawable = true;
+    root.traverse((object) => {
+        drawable &&= hasMaterialsForGroups(object);
+    });
+    if (!drawable)
+        return null;
     wallSlotRaycaster.ray.copy(ray);
     const hits = wallSlotRaycaster.intersectObject(root, true);
     for (const hit of hits) {
@@ -45,18 +39,20 @@ function resolveWallSlotByRay(node, ray) {
     return null;
 }
 /**
- * Resolve which wall face band the user clicked. The side comes from:
- *   1. Material-slot index from the renderer's groups. Cheap reference path.
- *   2. Falls back to the hit-surface normal + local-Z when the
- *      groups aren't conclusive. Front/back of the wall maps to the
- *      node's `frontSide` / `backSide` semantic; absent that, front
- *      → interior, back → exterior.
- *
- * Returns null when the click is too oblique (or lands on the wall's
- * end-cap, etc.) to confidently assign a side.
+ * Resolve which wall surface the user clicked: a trim slot, a paint region,
+ * the room finish on that face, or the face slot itself. Returns null when the
+ * click is too oblique (or lands on the wall's end-cap, etc.) to pick a face.
  */
 export function resolveWallRole(args) {
-    const { node, hitObject, materialIndex, normal, localPosition, ray } = args;
+    const { node, hitObject, localPosition, ray } = args;
+    if (node.wallType === 'curtain') {
+        const root = sceneRegistry.nodes.get(node.id);
+        if (!(root && ray))
+            return null;
+        wallSlotRaycaster.ray.copy(ray);
+        const hit = wallSlotRaycaster.intersectObject(root, false)[0];
+        return CURTAIN_WALL_ROLES[hit?.face?.materialIndex ?? -1] ?? null;
+    }
     const directSlotId = hitObject?.userData?.slotId;
     if (typeof directSlotId === 'string' && WALL_SLOT_IDS.has(directSlotId)) {
         return directSlotId;
@@ -64,87 +60,262 @@ export function resolveWallRole(args) {
     const raySlotId = resolveWallSlotByRay(node, ray);
     if (raySlotId)
         return raySlotId;
-    const indexedSlotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
-    const indexedSide = resolveSideFromMaterialIndex(materialIndex);
-    const sideFromIndex = indexedSide ?? null;
-    if (indexedSlotId && indexedSlotId !== 'interior' && indexedSlotId !== 'exterior') {
-        return indexedSlotId;
-    }
-    if (sideFromIndex && localPosition) {
-        const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
-        const bands = getWallFaceBandConfig(node, effectiveWallHeight);
-        if (!bands.enabled)
-            return sideFromIndex;
-        return getWallBandSlotId(sideFromIndex, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
+    // The underpinning's stemwall, below the finish carried over the rim.
+    if (node.underpinning && localPosition && localPosition[1] < -node.underpinning.rim) {
+        return 'foundation';
     }
-    if (sideFromIndex)
-        return sideFromIndex;
-    const normalZ = normal?.[2];
-    const localZ = localPosition?.[2];
-    const thickness = node.thickness ?? 0.1;
-    if (normalZ === undefined ||
-        localZ === undefined ||
-        localPosition === undefined ||
-        Math.abs(normalZ) < 0.65 ||
-        Math.abs(localZ) < Math.max(thickness * 0.2, 0.01)) {
+    // The physical face comes from where the hit lies, never from the material
+    // index: a region can draw with a face slot's material on the other face.
+    if (!localPosition)
         return null;
+    const face = getWallFaceAtLocalPoint(node, localPosition, args.normal);
+    if (!face)
+        return null;
+    const nodes = args.nodes ?? useScene.getState().nodes;
+    const layout = buildWallFinishLayout(node, getWallLevelZones(node, nodes));
+    if (layout.plain)
+        return face;
+    const mesh = sceneRegistry.nodes.get(node.id);
+    const u = localPosition[0];
+    const v = localPosition[1] - getWallFaceBaseAt(getWallFinishData(mesh?.geometry), face, u);
+    const hit = resolveWallFinish(layout, face, u, v);
+    if (hit.source === 'region')
+        return wallRegionRole(hit.regionId);
+    if (hit.source === 'override' || hit.source === 'zone')
+        return wallRoomFaceRole(hit.zoneId, face);
+    return face;
+}
+function zoneOf(zoneId, nodes = useScene.getState().nodes) {
+    const node = nodes[zoneId];
+    return node?.type === 'zone' ? node : null;
+}
+/** The finish ref a non-slot role currently shows, if any. */
+function currentRoleRef(wall, role, nodes) {
+    if (role.kind === 'region') {
+        return wall.faceRegions?.find((region) => region.id === role.regionId)?.finish;
     }
-    const hitFace = localZ >= 0 ? 'front' : 'back';
-    const semantic = hitFace === 'front' ? node.frontSide : node.backSide;
-    if (semantic === 'interior' || semantic === 'exterior') {
-        const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
-        const bands = getWallFaceBandConfig(node, effectiveWallHeight);
-        if (!bands.enabled)
-            return semantic;
-        return getWallBandSlotId(semantic, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
+    if (role.kind === 'room')
+        return zoneOf(role.zoneId, nodes)?.wallMaterial;
+    if (role.kind === 'room-face') {
+        const zone = zoneOf(role.zoneId, nodes);
+        return (zone?.wallOverrides?.find((entry) => entry.wallId === wall.id && entry.face === role.face)
+            ?.finish ?? zone?.wallMaterial);
     }
-    const side = hitFace === 'front' ? 'interior' : 'exterior';
-    const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
-    const bands = getWallFaceBandConfig(node, effectiveWallHeight);
-    if (!bands.enabled)
-        return side;
-    return getWallBandSlotId(side, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
+    return wall.slots?.[role.slotId];
+}
+function refToEffective(ref) {
+    const parsed = parseMaterialRef(ref);
+    if (parsed?.kind === 'library')
+        return { material: undefined, materialPreset: ref };
+    if (parsed?.kind === 'scene') {
+        const sceneMaterial = useScene.getState().materials[parsed.id];
+        if (sceneMaterial)
+            return { material: sceneMaterial.material, materialPreset: undefined };
+    }
+    return null;
+}
+/**
+ * The wall mesh's palette entry a non-face slot draws with, when it is part of
+ * the wall body rather than its own mesh: a curtain wall's frame / glass /
+ * solid panels (0..2), or the underpinning's stemwall (a finish ref, 3..).
+ */
+function wallPaletteSlotIndex(wall, slotId, mesh) {
+    if (isCurtainWallRole(slotId))
+        return CURTAIN_WALL_ROLES.indexOf(slotId);
+    if (slotId !== 'foundation' || !wall.underpinning)
+        return null;
+    const ref = wall.slots?.foundation ?? WALL_SURFACE_SLOT_DEFAULTS.foundation;
+    const at = getWallFinishRefs(mesh.geometry).indexOf(ref);
+    return at < 0 ? null : 3 + at;
+}
+/** Swap one palette entry of a copy of the wall's material array; cleanup restores it. */
+function previewPaletteEntry(args, mesh, index) {
+    const current = mesh.material;
+    if (!Array.isArray(current) || index >= current.length)
+        return () => { };
+    const preview = buildSlotPreviewMaterial(args.material, args.materialPreset);
+    if (!preview)
+        return () => { };
+    const next = current.slice();
+    next[index] = preview;
+    return swapPreviewMaterial(mesh, next);
+}
+/** The finish the preview plan writes, so the surfaces it lands on can be told apart. */
+const PREVIEW_REF = '__paint-preview__';
+function sameChain(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
 }
 /**
- * Preview a wall paint by swapping just the painted face's entry in the wall
- * mesh's material array. The array is the shared cached `WallMaterials.visible`,
- * so we clone it before swapping and restore the original reference on cleanup
- * (never mutate the cache).
+ * Preview a wall paint by drawing the plan the click commits: every face
+ * triangle of this wall is resolved again against the planned wall and rooms,
+ * and takes the material that resolution draws — the paint where the click
+ * paints, what shows once erased where it erases. The material array is copied
+ * (never the shared cache) and the triangles are regrouped; cleanup restores
+ * both.
  */
 function applyWallPreview(args) {
     const { role, material, materialPreset } = args;
-    if (!(role in WALL_ARRAY_SLOT_INDEX)) {
-        return previewSlotByUserData(args);
-    }
-    const index = WALL_ARRAY_SLOT_INDEX[role];
-    if (!index)
-        return previewSlotByUserData(args);
+    const parsed = parseWallPaintRole(role);
+    if (!parsed)
+        return null;
     const mesh = sceneRegistry.nodes.get(args.node.id);
-    if (!(mesh && mesh.isMesh))
+    if (parsed.kind === 'slot' && !(parsed.slotId === 'a' || parsed.slotId === 'b')) {
+        const index = mesh?.isMesh
+            ? wallPaletteSlotIndex(args.node, parsed.slotId, mesh)
+            : null;
+        return index === null ? previewSlotByUserData(args) : previewPaletteEntry(args, mesh, index);
+    }
+    if (!mesh?.isMesh)
         return null;
-    const wallMesh = mesh;
-    const current = wallMesh.material;
+    const current = mesh.material;
     if (!Array.isArray(current))
         return null;
-    const preview = buildSlotPreviewMaterial(material, materialPreset);
-    if (!preview)
+    const erasing = material === undefined && materialPreset === undefined;
+    const paint = erasing ? null : buildSlotPreviewMaterial(material, materialPreset);
+    if (!(erasing || paint))
         return () => { };
-    const previous = current;
-    const next = previous.slice();
-    next[index] = preview;
-    wallMesh.material = next;
+    const nodes = useScene.getState().nodes;
+    const before = (nodes[args.node.id] ?? args.node);
+    const plan = planWallPaint(nodes, before, parsed, erasing ? undefined : PREVIEW_REF);
+    const after = { ...nodes, ...plan };
+    const wall = (after[before.id] ?? before);
+    const layout = buildWallFinishLayout(wall, getWallLevelZones(wall, after));
+    const refs = getWallFinishRefs(mesh.geometry);
+    const chains = {
+        before: { a: resolveWallFaceChain(before, 'a'), b: resolveWallFaceChain(before, 'b') },
+        after: { a: resolveWallFaceChain(wall, 'a'), b: resolveWallFaceChain(wall, 'b') },
+    };
+    const materials = current.slice();
+    const added = new Map();
+    const extra = (key, make) => {
+        const known = added.get(key);
+        if (known !== undefined)
+            return known;
+        const made = make();
+        if (!made)
+            return null;
+        materials.push(made);
+        added.set(key, materials.length - 1);
+        return materials.length - 1;
+    };
+    const lookIndex = (look) => extra(`look:${JSON.stringify(look)}`, () => buildSlotPreviewMaterial(look.material, look.materialPreset));
+    const indexFor = (face, u, v) => {
+        const hit = resolveWallFinish(layout, face, u, v);
+        if (hit.source !== 'slot') {
+            if (hit.ref === PREVIEW_REF)
+                return extra('paint', () => paint);
+            const at = refs.indexOf(hit.ref);
+            return at >= 0 ? 3 + at : lookIndex({ materialPreset: hit.ref });
+        }
+        const chain = chains.after[face];
+        if (sameChain(chain, chains.before[face]))
+            return FACE_MATERIAL_INDEX[face];
+        if (chain.kind !== 'legacy' && chain.ref === PREVIEW_REF)
+            return extra('paint', () => paint);
+        return lookIndex(chain.kind === 'legacy' ? chain.spec : { materialPreset: chain.ref });
+    };
+    const geometry = mesh.geometry;
+    const groups = geometry.groups.map((group) => ({ ...group }));
+    const regrouped = regroupWallFaces(geometry, before, indexFor);
+    if (!regrouped)
+        return () => { };
+    geometry.groups = regrouped;
+    const restoreMaterial = swapPreviewMaterial(mesh, materials);
     return () => {
-        wallMesh.material = previous;
+        restoreMaterial();
+        if (mesh.geometry === geometry)
+            geometry.groups = groups;
     };
 }
 /**
- * Capability binding for the wall kind on the unified slot model. Painting
- * writes `node.slots[bandSide]` (a `library:` ref or a minted `scene:`
- * material) exactly like every other kind; `legacyEffective` reads the
- * whole-side fallback so old scenes still show the current value.
+ * The wall's face triangles regrouped by the material index `indexFor` gives
+ * each (the face and station its centre lies at); caps keep theirs. Null when
+ * nothing moves.
  */
-export const wallPaint = createSlotPaintCapability({
+export function regroupWallFaces(geometry, wall, indexFor) {
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return null;
+    const index = geometry.getIndex();
+    const vertex = (at) => (index ? index.getX(at) : at);
+    const finish = getWallFinishData(geometry);
+    const a = new Vector3();
+    const b = new Vector3();
+    const c = new Vector3();
+    const ab = new Vector3();
+    const ac = new Vector3();
+    const out = [];
+    let changed = false;
+    const push = (start, materialIndex) => {
+        const last = out[out.length - 1];
+        if (last && last.materialIndex === materialIndex && last.start + last.count === start)
+            last.count += 3;
+        else
+            out.push({ start, count: 3, materialIndex });
+    };
+    for (const group of geometry.groups) {
+        const own = group.materialIndex ?? 0;
+        for (let at = group.start; at + 2 < group.start + group.count; at += 3) {
+            let next = own;
+            if (own !== 0) {
+                a.fromBufferAttribute(position, vertex(at));
+                b.fromBufferAttribute(position, vertex(at + 1));
+                c.fromBufferAttribute(position, vertex(at + 2));
+                const centre = [
+                    (a.x + b.x + c.x) / 3,
+                    (a.y + b.y + c.y) / 3,
+                    (a.z + b.z + c.z) / 3,
+                ];
+                const normal = ab.subVectors(b, a).cross(ac.subVectors(c, a)).normalize();
+                const face = getWallFaceAtLocalPoint(wall, centre, [normal.x, normal.y, normal.z]);
+                if (face) {
+                    const v = centre[1] - getWallFaceBaseAt(finish, face, centre[0]);
+                    next = indexFor(face, centre[0], v) ?? own;
+                }
+            }
+            if (next !== own)
+                changed = true;
+            push(at, next);
+        }
+    }
+    return changed ? out : null;
+}
+/**
+ * Write a wall paint in one history step through the same plan the preview
+ * draws, minting the shared scene material the way `commitSlotPaint` does so a
+ * one-off colour is stored once.
+ */
+function commitWallPlan(wallId, role, material, materialPreset) {
+    const state = useScene.getState();
+    const resolution = resolveSlotPaintMaterialRef(state.materials, material, materialPreset);
+    if (!resolution)
+        return;
+    const { ref, newSceneMaterial } = resolution;
+    let touched = [];
+    useScene.setState((current) => {
+        if (current.readOnly)
+            return current;
+        const wall = current.nodes[wallId];
+        if (wall?.type !== 'wall')
+            return current;
+        const plan = planWallPaint(current.nodes, wall, role, ref);
+        if (!Object.keys(plan).length)
+            return current;
+        touched = plannedWallIds(current.nodes, plan);
+        return {
+            ...(newSceneMaterial
+                ? { materials: { ...current.materials, [newSceneMaterial.id]: newSceneMaterial } }
+                : {}),
+            nodes: { ...current.nodes, ...plan },
+        };
+    });
+    for (const id of new Set([wallId, ...touched]))
+        useScene.getState().markDirty(id);
+}
+const base = createSlotPaintCapability({
     roomScope: true,
+    // The preview draws the erase plan itself.
+    erasedLook: () => null,
     resolveRole: ({ node, hitObject, materialIndex, normal, localPosition, ray }) => resolveWallRole({
         node: node,
         hitObject: hitObject,
@@ -155,28 +326,81 @@ export const wallPaint = createSlotPaintCapability({
     }),
     applyPreview: applyWallPreview,
     legacyEffective: (node, role) => {
-        const side = getWallSurfaceSideFromBandSlot(role);
-        if (!side && role in WALL_SURFACE_SLOT_DEFAULTS) {
+        if (node.type === 'wall' && node.wallType === 'curtain') {
+            const config = getCurtainWallConfig(node);
+            const color = role === 'curtain-frame'
+                ? config.frameColor
+                : role === 'curtain-glass'
+                    ? config.glassColor
+                    : role === 'curtain-solid'
+                        ? config.solidColor
+                        : undefined;
+            if (!color)
+                return null;
+            return {
+                materialPreset: undefined,
+                material: {
+                    preset: 'custom',
+                    properties: {
+                        color,
+                        roughness: role === 'curtain-glass' ? config.glassRoughness : 0.4,
+                        metalness: role === 'curtain-frame' ? 0.65 : 0,
+                        opacity: role === 'curtain-glass' ? config.glassOpacity : 1,
+                        transparent: role === 'curtain-glass',
+                        side: 'front',
+                    },
+                },
+            };
+        }
+        if (role === 'a' || role === 'b') {
+            const spec = getEffectiveWallFaceMaterial(node, role);
+            if (spec.material === undefined && spec.materialPreset === undefined)
+                return null;
+            return { material: spec.material, materialPreset: spec.materialPreset };
+        }
+        if (role in WALL_SURFACE_SLOT_DEFAULTS) {
             return {
                 material: undefined,
                 materialPreset: WALL_SURFACE_SLOT_DEFAULTS[role],
             };
         }
-        if (!side)
-            return null;
-        const sideRef = node.slots?.[side];
-        const parsed = parseMaterialRef(sideRef);
-        if (parsed?.kind === 'library') {
-            return { material: undefined, materialPreset: sideRef };
-        }
-        if (parsed?.kind === 'scene') {
-            const sceneMaterial = useScene.getState().materials[parsed.id];
-            if (sceneMaterial)
-                return { material: sceneMaterial.material, materialPreset: undefined };
+        return null;
+    },
+});
+/**
+ * Capability binding for the wall kind on the unified slot model. Face and trim
+ * slots write `node.slots[slotId]` like every other kind; regions write the
+ * region's finish and room roles write the zone, because a room's wall finish
+ * belongs to the room, not to one of its walls.
+ */
+export const wallPaint = {
+    ...base,
+    roleLabel: (_node, role) => {
+        const parsed = parseWallPaintRole(role);
+        if (parsed?.kind === 'region' || parsed?.kind === 'room-face')
+            return 'Face';
+        if (parsed?.kind === 'room')
+            return 'Room';
+        return null;
+    },
+    buildPatch: (args) => parseWallPaintRole(args.role)?.kind === 'slot' ? base.buildPatch(args) : {},
+    commit: (args) => {
+        const parsed = parseWallPaintRole(args.role);
+        if (!parsed)
+            return;
+        // A trim is a slot like any other; faces, regions and rooms go through the plan.
+        if (parsed.kind === 'slot' && parsed.slotId !== 'a' && parsed.slotId !== 'b') {
+            base.commit?.(args);
+            return;
         }
-        const spec = getEffectiveWallSurfaceMaterial(node, side);
-        if (spec.material === undefined && spec.materialPreset === undefined)
+        commitWallPlan(args.node.id, parsed, args.material, args.materialPreset);
+    },
+    getEffectiveMaterial: (args) => {
+        const parsed = parseWallPaintRole(args.role);
+        if (!parsed)
             return null;
-        return { material: spec.material, materialPreset: spec.materialPreset };
+        if (parsed.kind === 'slot')
+            return base.getEffectiveMaterial?.(args) ?? null;
+        return refToEffective(currentRoleRef(args.node, parsed, args.nodes));
     },
-});
+};

package/dist/wall/panel-model.d.ts

@@ -0,0 +1,22 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+import { type PanelRow } from '@pascal-app/editor';
+export type WallReferenceValue = 'outside' | 'center' | 'inside' | 'left' | 'right';
+export type WallReferenceOption = {
+    label: string;
+    value: WallReferenceValue;
+};
+/**
+ * The Reference control for one or more walls. The drawn line never moves; the
+ * choice picks which face sits on it. Walls with a room on exactly one side read
+ * Outside face / Center / Inside face; otherwise Left / Center / Right along the
+ * drawing direction (left is face a). A selection shows the room labels only
+ * when every wall has them, applies each choice to each wall's own faces, and
+ * shows no active option when the walls disagree.
+ */
+export declare function wallReferenceModel(walls: readonly WallNode[], nodes: Record<AnyNodeId, AnyNode>): {
+    options: WallReferenceOption[];
+    value: WallReferenceValue | null;
+    apply: (next: WallReferenceValue) => void;
+};
+export declare function wallSettings(node: WallNode, nodes: Record<AnyNodeId, AnyNode>, update: (patch: Partial<WallNode>) => void, reshape?: () => void): PanelRow[];
+//# sourceMappingURL=panel-model.d.ts.map

package/dist/wall/panel-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/wall/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAed,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAiB3B,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAqB9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;kBAsB9E,kBAAkB;EAYnC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAId,GACA,QAAQ,EAAE,CA8LZ"}