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

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

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-resize.d.ts","sourceRoot":"","sources":["../../src/cabinet/hosted-resize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AACvC,KAAK,MAAM,GAAG,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;AASpD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,GAAG,IAAI,CAiFtF;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,GAChC,MAAM,EAAE,GAAG,IAAI,CA8BjB;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,OAAO,EACzD,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC9B,gBAAgB,CAAC,CAAC,CAAC,CA8CrB"}

package/dist/cabinet/hosted-resize.js

@@ -0,0 +1,158 @@
+import { getScaledDimensions, getSurfaceProvider, nodeRegistry, surfaceRegionContainsFootprint, } from '@pascal-app/core';
+import { boundsOf, boxCorners, frame, transformPoint } from '@pascal-app/core/procedural-items';
+function surfaceScene(nodes) {
+    return {
+        nodes: () => nodes,
+        get: (id) => nodes[id],
+    };
+}
+export function cabinetHostedChildUpdates(before, after) {
+    const updates = [];
+    for (const host of Object.values(before)) {
+        if (host.type !== 'cabinet')
+            continue;
+        const children = host.children
+            .map((id) => before[id])
+            .filter((child) => child?.parentId === host.id &&
+            child.type !== 'cabinet' &&
+            child.type !== 'cabinet-module');
+        if (!children.length)
+            continue;
+        const nextHost = after[host.id];
+        if (nextHost?.type !== 'cabinet')
+            return null;
+        const provider = getSurfaceProvider(host);
+        const nextSurfaces = provider.surfaces?.(nextHost, { scene: surfaceScene(after) }) ?? [];
+        if (JSON.stringify(provider.surfaces?.(host, { scene: surfaceScene(before) })) ===
+            JSON.stringify(nextSurfaces))
+            continue;
+        for (const child of children) {
+            if (!child || !('position' in child) || !('rotation' in child))
+                continue;
+            const bounds = child.type === 'item'
+                ? { size: getScaledDimensions(child), center: undefined }
+                : nodeRegistry.get(child.type)?.capabilities.dragBounds?.(child, before);
+            if (!bounds)
+                continue;
+            const center = bounds.center ?? [0, bounds.size[1] / 2, 0];
+            const localBounds = {
+                min: center.map((v, i) => v - bounds.size[i] / 2),
+                max: center.map((v, i) => v + bounds.size[i] / 2),
+            };
+            const position = child.position;
+            const rotation = (typeof child.rotation === 'number' ? [0, child.rotation, 0] : child.rotation);
+            const projected = boundsOf(boxCorners(localBounds.min, localBounds.max).map((p) => transformPoint(frame(position, rotation), p)));
+            const hit = {
+                point: [
+                    (projected.min[0] + projected.max[0]) / 2,
+                    projected.min[1],
+                    (projected.min[2] + projected.max[2]) / 2,
+                ],
+                normalWorldY: 1,
+            };
+            const previousSurface = provider.resolveHit(host, hit, { scene: surfaceScene(before) });
+            if (!previousSurface || Math.abs(previousSurface.position[1] - projected.min[1]) > 1e-5)
+                continue;
+            const nextSurface = nextSurfaces.find((surface) => surface.id === previousSurface.id);
+            if (!nextSurface)
+                return null;
+            const nextPosition = [
+                position[0],
+                position[1] + nextSurface.position[1] - previousSurface.position[1],
+                position[2],
+            ];
+            const surfaceLocal = [
+                nextPosition[0] - nextSurface.position[0],
+                nextPosition[1] - nextSurface.position[1],
+                nextPosition[2] - nextSurface.position[2],
+            ];
+            if (!surfaceRegionContainsFootprint(nextSurface.region, surfaceLocal, bounds.size, rotation, localBounds))
+                return null;
+            if (Math.abs(nextPosition[1] - position[1]) > 1e-8)
+                updates.push([child.id, { position: nextPosition }]);
+        }
+    }
+    return updates;
+}
+export function planCabinetHostedEdit(sceneApi, apply) {
+    const before = sceneApi.nodes();
+    const after = { ...before };
+    const updates = new Map();
+    let supported = true;
+    const staged = {
+        ...sceneApi,
+        ...surfaceScene(after),
+        update(id, data) {
+            if (!after[id])
+                return;
+            after[id] = { ...after[id], ...data };
+            updates.set(id, { ...updates.get(id), ...data });
+        },
+        upsert(node) {
+            supported = false;
+            return node.id;
+        },
+        delete() {
+            supported = false;
+        },
+        markDirty() { },
+        pauseHistory() { },
+        resumeHistory() { },
+    };
+    apply(staged);
+    if (!supported)
+        return null;
+    const children = cabinetHostedChildUpdates(before, after);
+    if (!children)
+        return null;
+    for (const [id, data] of children)
+        updates.set(id, data);
+    return [...updates];
+}
+export function withCabinetHostedChildren(descriptor) {
+    if (descriptor.kind !== 'linear-resize')
+        return descriptor;
+    const plan = (node, patch, sceneApi, modifiers) => planCabinetHostedEdit(sceneApi, (staged) => {
+        if (descriptor.commit)
+            descriptor.commit(node, patch, staged, modifiers);
+        else
+            staged.update(descriptor.overrideTarget?.(node, staged) ?? node.id, patch);
+    });
+    const hasHostedChildren = (scene) => Object.values(scene?.nodes() ?? {}).some((node) => node.type === 'cabinet' &&
+        node.children.some((id) => {
+            const child = scene.get(id);
+            return child && child.type !== 'cabinet' && child.type !== 'cabinet-module';
+        }));
+    return {
+        ...descriptor,
+        apply(node, value, sceneApi, modifiers) {
+            const patch = descriptor.apply(node, value, sceneApi, modifiers);
+            if (!hasHostedChildren(sceneApi) || plan(node, patch, sceneApi, modifiers))
+                return patch;
+            const target = sceneApi.get(descriptor.overrideTarget?.(node, sceneApi) ?? node.id) ?? node;
+            return Object.fromEntries(Object.keys(patch).map((key) => [key, target[key]]));
+        },
+        previewOverrides(node, value, sceneApi, modifiers) {
+            if (!hasHostedChildren(sceneApi))
+                return descriptor.previewOverrides?.(node, value, sceneApi, modifiers) ?? [];
+            const patch = descriptor.apply(node, value, sceneApi, modifiers);
+            return plan(node, patch, sceneApi, modifiers) ?? [];
+        },
+        commit(node, patch, sceneApi, modifiers) {
+            if (!hasHostedChildren(sceneApi)) {
+                if (descriptor.commit)
+                    descriptor.commit(node, patch, sceneApi, modifiers);
+                else
+                    sceneApi.update(descriptor.overrideTarget?.(node, sceneApi) ?? node.id, patch);
+                return;
+            }
+            const updates = plan(node, patch, sceneApi, modifiers);
+            if (!updates)
+                return;
+            for (const [id, data] of updates) {
+                sceneApi.update(id, data);
+                sceneApi.markDirty(id);
+            }
+        },
+    };
+}

package/dist/cabinet/index.d.ts

@@ -2,4 +2,5 @@ export { bakeCabinetAnimationClip, poseCabinetMovingParts } from './animation';
 export { cabinetDefinition, cabinetModuleDefinition } from './definition';
 export { default as useCabinetPlacementStatus } from './placement-status';
 export { type CabinetPlacementType, default as useCabinetPlacementType, } from './placement-type';
+export { CABINET_PLANNING_TOLERANCE, type CabinetPlanningIssue, type CabinetPlanningIssueCode, type CabinetPlanningOptions, type CabinetPlanningReport, MIN_PRACTICAL_TOP_CABINET_HEIGHT, validateCabinetRun, } from './validation';
 //# sourceMappingURL=index.d.ts.map

package/dist/cabinet/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cabinet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AACzE,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,OAAO,IAAI,uBAAuB,GACnC,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cabinet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AACzE,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,OAAO,IAAI,uBAAuB,GACnC,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,gCAAgC,EAChC,kBAAkB,GACnB,MAAM,cAAc,CAAA"}

package/dist/cabinet/index.js

@@ -2,3 +2,4 @@ export { bakeCabinetAnimationClip, poseCabinetMovingParts } from './animation';
 export { cabinetDefinition, cabinetModuleDefinition } from './definition';
 export { default as useCabinetPlacementStatus } from './placement-status';
 export { default as useCabinetPlacementType, } from './placement-type';
+export { CABINET_PLANNING_TOLERANCE, MIN_PRACTICAL_TOP_CABINET_HEIGHT, validateCabinetRun, } from './validation';

package/dist/cabinet/insertion.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNodeId, CabinetModuleNode, CabinetNode, SceneApi } from '@pascal-app/core';
+export declare function cabinetModuleForRunInsertion(module: CabinetModuleNode, run: CabinetNode): CabinetModuleNode;
+export declare function applyCabinetModuleInsertion({ module, plan, run, sceneApi, }: {
+    module: CabinetModuleNode;
+    plan: {
+        modules: ReadonlyArray<{
+            id: AnyNodeId;
+            position: [number, number, number];
+            width: number;
+        }>;
+        inserted: {
+            position: [number, number, number];
+            width: number;
+        };
+    };
+    run: CabinetNode;
+    sceneApi: SceneApi;
+}): AnyNodeId | null;
+//# sourceMappingURL=insertion.d.ts.map

package/dist/cabinet/insertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertion.d.ts","sourceRoot":"","sources":["../../src/cabinet/insertion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEpG,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,iBAAiB,EACzB,GAAG,EAAE,WAAW,GACf,iBAAiB,CAWnB;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,MAAM,EACN,IAAI,EACJ,GAAG,EACH,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,iBAAiB,CAAA;IACzB,IAAI,EAAE;QACJ,OAAO,EAAE,aAAa,CAAC;YACrB,EAAE,EAAE,SAAS,CAAA;YACb,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;YAClC,KAAK,EAAE,MAAM,CAAA;SACd,CAAC,CAAA;QACF,QAAQ,EAAE;YACR,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;YAClC,KAAK,EAAE,MAAM,CAAA;SACd,CAAA;KACF,CAAA;IACD,GAAG,EAAE,WAAW,CAAA;IAChB,QAAQ,EAAE,QAAQ,CAAA;CACnB,GAAG,SAAS,GAAG,IAAI,CAuCnB"}

package/dist/cabinet/insertion.js

@@ -0,0 +1,49 @@
+export function cabinetModuleForRunInsertion(module, run) {
+    return {
+        ...module,
+        parentId: run.id,
+        plinthHeight: run.plinthHeight,
+        showPlinth: false,
+        countertopThickness: 0,
+        countertopOverhang: run.countertopOverhang,
+        countertopBackOverhang: run.countertopBackOverhang,
+        withCountertop: false,
+    };
+}
+export function applyCabinetModuleInsertion({ module, plan, run, sceneApi, }) {
+    const liveRun = sceneApi.get(run.id);
+    if (!liveRun)
+        return null;
+    const plannedIds = new Set(plan.modules.map((entry) => entry.id));
+    for (const planned of plan.modules) {
+        const current = sceneApi.get(planned.id);
+        if (!current || current.parentId !== liveRun.id)
+            return null;
+        sceneApi.update(current.id, {
+            position: planned.position,
+            width: planned.width,
+        });
+    }
+    const inserted = {
+        ...cabinetModuleForRunInsertion(module, liveRun),
+        position: plan.inserted.position,
+        width: plan.inserted.width,
+    };
+    sceneApi.upsert(inserted, liveRun.id);
+    const orderedModules = [
+        ...plan.modules.map((entry) => ({ id: entry.id, x: entry.position[0] })),
+        { id: inserted.id, x: inserted.position[0] },
+    ].sort((left, right) => left.x - right.x);
+    const otherChildren = (liveRun.children ?? []).filter((id) => !plannedIds.has(id) && id !== inserted.id);
+    const allModules = [
+        ...plan.modules.map((entry) => ({ width: entry.width, x: entry.position[0] })),
+        { width: inserted.width, x: inserted.position[0] },
+    ];
+    const minX = Math.min(...allModules.map(({ x, width }) => x - width / 2));
+    const maxX = Math.max(...allModules.map(({ x, width }) => x + width / 2));
+    sceneApi.update(liveRun.id, {
+        children: [...otherChildren, ...orderedModules.map(({ id }) => id)],
+        width: maxX - minX,
+    });
+    return inserted.id;
+}

package/dist/cabinet/move-frame.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-frame.d.ts","sourceRoot":"","sources":["../../src/cabinet/move-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AAiSzB,eAAO,MAAM,wBAAwB,EAAE,kBAgCtC,CAAA"}
+{"version":3,"file":"move-frame.d.ts","sourceRoot":"","sources":["../../src/cabinet/move-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AA8VzB,eAAO,MAAM,wBAAwB,EAAE,kBAwDtC,CAAA"}

package/dist/cabinet/move-frame.js

@@ -1,8 +1,52 @@
-import { planToRunLocal, runLocalToPlan } from './run-layout';
-import { bumpCabinetRunLayoutRevision, syncCornerRunsFromSourceModule } from './run-ops';
+import { findLevelAncestorId } from '@pascal-app/core';
+import { findWallOpeningConflicts } from '../shared/wall-opening-clearance';
+import { moduleMaxX, moduleMinX, planToRunLocal, runLocalToPlan } from './run-layout';
+import { bumpCabinetRunLayoutRevision, cabinetModulesForRun, cabinetModuleTotalHeight, previewCornerRunsFromRunSources, syncCornerRunsFromSourceModule, } from './run-ops';
+import { findClosestCabinetWallInPlan, resolveCabinetWallFaceOffset } from './wall-snap';
 /** Matches the generic move tool's Figma-alignment pull (8 cm). */
 const MAGNETIC_THRESHOLD_M = 0.08;
 const GUIDE_EPSILON_M = 1e-4;
+function modulesOverlap(a, b) {
+    const xOverlap = moduleMinX(a) < moduleMaxX(b) - GUIDE_EPSILON_M &&
+        moduleMaxX(a) > moduleMinX(b) + GUIDE_EPSILON_M;
+    const aMinZ = a.position[2] - a.depth / 2;
+    const aMaxZ = a.position[2] + a.depth / 2;
+    const bMinZ = b.position[2] - b.depth / 2;
+    const bMaxZ = b.position[2] + b.depth / 2;
+    return xOverlap && aMinZ < bMaxZ - GUIDE_EPSILON_M && aMaxZ > bMinZ + GUIDE_EPSILON_M;
+}
+function moduleOverlapsWallOpening(module, parent, position, nodes) {
+    const levelId = findLevelAncestorId(parent.id, nodes);
+    if (!levelId)
+        return false;
+    const planPosition = localToPlan(parent, position, nodes);
+    const hit = findClosestCabinetWallInPlan({
+        excludeIds: [],
+        nodes: nodes,
+        parentLevelId: levelId,
+        planPoint: [planPosition[0], planPosition[2]],
+        yaw: frameWorldTransform(parent, nodes).rotation + module.rotation,
+    });
+    if (!hit)
+        return false;
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const expectedPerp = resolveCabinetWallFaceOffset({
+        hit,
+        nodes: nodes,
+        parentLevelId: levelId,
+    }) +
+        normalScale * (module.depth / 2);
+    if (Math.abs(hit.perpDistance - expectedPerp) > 0.12)
+        return false;
+    return (findWallOpeningConflicts({
+        bottom: planPosition[1],
+        height: cabinetModuleTotalHeight(module),
+        localX: hit.localX,
+        nodes: nodes,
+        wall: hit.wall,
+        width: module.width,
+    }).length > 0);
+}
 function frameParent(node, nodes) {
     if (node.type !== 'cabinet-module' || !node.parentId)
         return null;
@@ -224,6 +268,28 @@ export const cabinetModuleParentFrame = {
     planToLocal,
     magneticSnap,
     magneticSnapMatches,
+    previewOverrides: ({ node, parent, position, sceneApi }) => {
+        if (node.type !== 'cabinet-module' || parent.type !== 'cabinet')
+            return [];
+        return previewCornerRunsFromRunSources({
+            initialOverrides: [[node.id, { position: [...position] }]],
+            previousModules: [node],
+            run: parent,
+            sceneApi,
+        }).filter(([id]) => id !== node.id);
+    },
+    isValidPosition: ({ node, parent, position, nodes }) => {
+        if (node.type !== 'cabinet-module' || parent.type !== 'cabinet')
+            return true;
+        const moving = { ...node, position: [...position] };
+        const siblingConflict = cabinetModulesForRun(parent, nodes).some((sibling) => {
+            if (sibling.id === moving.id)
+                return false;
+            return modulesOverlap(moving, sibling);
+        });
+        return (!siblingConflict &&
+            !moduleOverlapsWallOpening(moving, parent, position, nodes));
+    },
     // Module position isn't in the run's geometryKey, so a committed move must
     // bump the layout revision to re-flow spans/countertop — and re-anchor any
     // linked L-corner runs to the module's new edge.

package/dist/cabinet/panel-context.d.ts

@@ -0,0 +1,7 @@
+import type { AnyNode, AnyNodeId, CabinetModuleNode, CabinetNode } from '@pascal-app/core';
+export type CabinetModulePanelContext = {
+    parentRun: CabinetNode;
+    reflowModule: CabinetModuleNode | null;
+};
+export declare function cabinetModulePanelContext(module: CabinetModuleNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): CabinetModulePanelContext | null;
+//# sourceMappingURL=panel-context.d.ts.map

package/dist/cabinet/panel-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-context.d.ts","sourceRoot":"","sources":["../../src/cabinet/panel-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE1F,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,EAAE,WAAW,CAAA;IACtB,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACvC,CAAA;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GACnD,yBAAyB,GAAG,IAAI,CAgBlC"}

package/dist/cabinet/panel-context.js

@@ -0,0 +1,16 @@
+export function cabinetModulePanelContext(module, nodes) {
+    const directParentId = module.parentId;
+    let current = directParentId ? nodes[directParentId] : undefined;
+    const visited = new Set();
+    while (current && !visited.has(current.id)) {
+        visited.add(current.id);
+        if (current.type === 'cabinet') {
+            return {
+                parentRun: current,
+                reflowModule: current.id === directParentId ? module : null,
+            };
+        }
+        current = current.parentId ? nodes[current.parentId] : undefined;
+    }
+    return null;
+}

package/dist/cabinet/panel-visibility.d.ts

@@ -0,0 +1,9 @@
+import type { CabinetModuleNode, CabinetNode } from '@pascal-app/core';
+export declare function cabinetModuleSupportsPresets(module: CabinetModuleNode): boolean;
+export declare function cabinetModuleUsesFixedApplianceWidth(module: CabinetModuleNode): boolean;
+export declare function cabinetModuleSupportsTopFinish({ module, parentIsModule, parentRun, }: {
+    module: CabinetModuleNode;
+    parentIsModule: boolean;
+    parentRun?: CabinetNode;
+}): boolean;
+//# sourceMappingURL=panel-visibility.d.ts.map

package/dist/cabinet/panel-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-visibility.d.ts","sourceRoot":"","sources":["../../src/cabinet/panel-visibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAkBtE,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,iBAAiB,WAErE;AAED,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,iBAAiB,WAI7E;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,MAAM,EACN,cAAc,EACd,SAAS,GACV,EAAE;IACD,MAAM,EAAE,iBAAiB,CAAA;IACzB,cAAc,EAAE,OAAO,CAAA;IACvB,SAAS,CAAC,EAAE,WAAW,CAAA;CACxB,WAOA"}

package/dist/cabinet/panel-visibility.js

@@ -0,0 +1,26 @@
+import { resolveCabinetType } from './run-ops';
+const FIXED_WIDTH_APPLIANCE_TYPES = new Set([
+    'oven',
+    'microwave',
+    'dishwasher',
+    'sink',
+    'cooktop-gas',
+    'cooktop-induction',
+    'pull-out-pantry',
+    'fridge-single',
+    'fridge-double',
+    'fridge-top-freezer',
+    'fridge-bottom-freezer',
+]);
+export function cabinetModuleSupportsPresets(module) {
+    return module.moduleKind !== 'corner-filler';
+}
+export function cabinetModuleUsesFixedApplianceWidth(module) {
+    return (module.stack?.some((compartment) => FIXED_WIDTH_APPLIANCE_TYPES.has(compartment.type)) ?? false);
+}
+export function cabinetModuleSupportsTopFinish({ module, parentIsModule, parentRun, }) {
+    return (module.moduleKind === 'corner-filler' ||
+        parentIsModule ||
+        resolveCabinetType(module, parentRun) === 'tall' ||
+        parentRun?.runTier === 'wall');
+}

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cabinet/panel.tsx"],"names":[],"mappings":"AA2FA,MAAM,CAAC,OAAO,UAAU,YAAY,uCA4jBnC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cabinet/panel.tsx"],"names":[],"mappings":"AAsIA,MAAM,CAAC,OAAO,UAAU,YAAY,uCA45BnC"}