@pascal-app/nodes 0.1.1

package/dist/cabinet/run-layout.js

@@ -0,0 +1,315 @@
+/**
+ * Straight-line run layout math — the single home for the "modules sit on the
+ * run's local X axis" assumption. Ordering, edges, adjacency, spans, and
+ * insert positions all live here so a future corner (L-shape) module changes
+ * one file instead of five call sites.
+ */
+export const RUN_ADJACENCY_EPSILON = 1e-4;
+const ADJACENT_RUN_EPSILON = 1e-4;
+const ADJACENT_RUN_Z_TOLERANCE = 0.03;
+export function sortRunModules(modules) {
+    return [...modules].sort((a, b) => a.position[0] - b.position[0]);
+}
+export function moduleMinX(module) {
+    return module.position[0] - module.width / 2;
+}
+export function moduleMaxX(module) {
+    return module.position[0] + module.width / 2;
+}
+export function runMinX(modules) {
+    return Math.min(...modules.map(moduleMinX));
+}
+export function runMaxX(modules) {
+    return Math.max(...modules.map(moduleMaxX));
+}
+/**
+ * Whether a module's side has no flush neighbor — i.e. the side is free for a
+ * width-resize handle or an adjacent insert.
+ */
+export function moduleSideOpen(modules, moduleId, side, epsilon = RUN_ADJACENCY_EPSILON) {
+    const sorted = sortRunModules(modules);
+    const index = sorted.findIndex((entry) => entry.id === moduleId);
+    if (index < 0)
+        return true;
+    const module = sorted[index];
+    const neighbor = side === 'left' ? sorted[index - 1] : sorted[index + 1];
+    if (!neighbor)
+        return true;
+    const edge = side === 'left' ? moduleMinX(module) : moduleMaxX(module);
+    const neighborEdge = side === 'left' ? moduleMaxX(neighbor) : moduleMinX(neighbor);
+    return Math.abs(edge - neighborEdge) > epsilon;
+}
+/**
+ * Contiguous same-height module groups along the run — the units the
+ * countertop, plinth, and appliance-gap logic operate on. A gap, a
+ * base↔tall transition, or a top-height change starts a new span.
+ */
+export function getRunSpans(modules, opts = {}) {
+    const sorted = [...modules].sort((a, b) => a.position[0] - b.position[0]);
+    const spans = [];
+    const runTier = opts.runTier ?? 'base';
+    for (const module of sorted) {
+        const minX = module.position[0] - module.width / 2;
+        const maxX = module.position[0] + module.width / 2;
+        const minZ = module.position[2] - module.depth / 2;
+        const maxZ = module.position[2] + module.depth / 2;
+        const topY = module.position[1] + module.carcassHeight;
+        const hasCountertop = runTier === 'base' && (module.cabinetType ?? 'base') !== 'tall';
+        const current = spans.at(-1);
+        if (!current ||
+            minX - current.maxX > RUN_ADJACENCY_EPSILON ||
+            current.hasCountertop !== hasCountertop ||
+            Math.abs(current.topY - topY) > RUN_ADJACENCY_EPSILON) {
+            spans.push({
+                minX,
+                maxX,
+                centerX: module.position[0],
+                centerZ: module.position[2],
+                width: module.width,
+                depth: module.depth,
+                minZ,
+                maxZ,
+                topY,
+                hasCountertop,
+            });
+            continue;
+        }
+        current.maxX = Math.max(current.maxX, maxX);
+        current.minZ = Math.min(current.minZ, minZ);
+        current.maxZ = Math.max(current.maxZ, maxZ);
+        current.width = Math.max(0.01, current.maxX - current.minX);
+        current.centerX = (current.minX + current.maxX) / 2;
+        current.depth = Math.max(0.01, current.maxZ - current.minZ);
+        current.centerZ = (current.minZ + current.maxZ) / 2;
+        current.topY = Math.max(current.topY, topY);
+    }
+    return spans;
+}
+function angleDelta(a, b) {
+    return Math.atan2(Math.sin(a - b), Math.cos(a - b));
+}
+export function derivedCornerRole(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return null;
+    const value = metadata.cabinetCornerDerivedRun;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const role = value.role;
+    const side = value.side;
+    if ((role !== 'base-leg' && role !== 'wall-leg' && role !== 'bridge') ||
+        (side !== 'left' && side !== 'right')) {
+        return null;
+    }
+    return { role, side };
+}
+function childDerivedBaseLegSides(ctx) {
+    const sides = new Set();
+    for (const child of ctx?.children ?? []) {
+        if (child.type !== 'cabinet')
+            continue;
+        const link = derivedCornerRole(child.metadata);
+        if (link?.role === 'base-leg')
+            sides.add(link.side);
+    }
+    return sides;
+}
+function modulesForRun(node, ctx) {
+    return (node.children ?? [])
+        .map((id) => ctx?.resolve(id))
+        .filter((child) => child?.type === 'cabinet-module');
+}
+function siblingCabinetSpansInRunLocal(node, ctx) {
+    if (!ctx)
+        return [];
+    const localX = [Math.cos(node.rotation), -Math.sin(node.rotation)];
+    const localZ = [Math.sin(node.rotation), Math.cos(node.rotation)];
+    const spans = [];
+    for (const sibling of ctx.siblings) {
+        if (sibling.type !== 'cabinet' || sibling.id === node.id)
+            continue;
+        if (Math.abs(angleDelta(sibling.rotation, node.rotation)) > 1e-3)
+            continue;
+        const siblingModules = modulesForRun(sibling, ctx);
+        const siblingSpans = siblingModules.length > 0
+            ? getRunSpans(siblingModules, { runTier: sibling.runTier })
+            : [
+                {
+                    minX: -sibling.width / 2,
+                    maxX: sibling.width / 2,
+                    centerX: 0,
+                    centerZ: 0,
+                    width: sibling.width,
+                    depth: sibling.depth,
+                    minZ: -sibling.depth / 2,
+                    maxZ: sibling.depth / 2,
+                    topY: sibling.carcassHeight,
+                    hasCountertop: sibling.runTier !== 'tall',
+                },
+            ];
+        const dx = sibling.position[0] - node.position[0];
+        const dz = sibling.position[2] - node.position[2];
+        const originX = dx * localX[0] + dz * localX[1];
+        const originZ = dx * localZ[0] + dz * localZ[1];
+        for (const span of siblingSpans) {
+            spans.push({
+                minX: originX + span.minX,
+                maxX: originX + span.maxX,
+                depth: span.depth,
+                z: originZ + span.centerZ,
+            });
+        }
+    }
+    return spans;
+}
+function hasAdjacentCabinetSpan({ depth, edgeX, overhang, side, siblingSpans, }) {
+    return siblingSpans.some((sibling) => {
+        if (Math.abs(sibling.z) > (depth + sibling.depth) / 2 + ADJACENT_RUN_Z_TOLERANCE) {
+            return false;
+        }
+        const gap = side === 'left' ? edgeX - sibling.maxX : sibling.minX - edgeX;
+        return gap >= -ADJACENT_RUN_EPSILON && gap <= overhang + ADJACENT_RUN_EPSILON;
+    });
+}
+/**
+ * Per-span end conditions shared by the 3D run geometry and the 2D plan
+ * outline, so the countertop reads identically in both views. The side
+ * overhang is suppressed where a span abuts a tall neighbor in the same run,
+ * an adjacent collinear run, a side bar ledge, or the mating edge of an
+ * L-corner leg (either direction of the link).
+ */
+export function getRunSpanEnds(node, ctx, spans) {
+    const siblingSpans = siblingCabinetSpansInRunLocal(node, ctx);
+    const cornerLink = derivedCornerRole(node.metadata);
+    const childBaseLegSides = childDerivedBaseLegSides(ctx);
+    const barEdge = node.barLedge?.edge;
+    return spans.map((span, spanIndex) => {
+        const previousSpan = spans[spanIndex - 1];
+        const nextSpan = spans[spanIndex + 1];
+        const hasInternalLeftNeighbor = !!previousSpan &&
+            !previousSpan.hasCountertop &&
+            span.minX - previousSpan.maxX <= RUN_ADJACENCY_EPSILON;
+        const hasInternalRightNeighbor = !!nextSpan && !nextSpan.hasCountertop && nextSpan.minX - span.maxX <= RUN_ADJACENCY_EPSILON;
+        const hasExternalLeftNeighbor = hasAdjacentCabinetSpan({
+            depth: span.depth,
+            edgeX: span.minX,
+            overhang: node.countertopOverhang,
+            side: 'left',
+            siblingSpans,
+        });
+        const hasExternalRightNeighbor = hasAdjacentCabinetSpan({
+            depth: span.depth,
+            edgeX: span.maxX,
+            overhang: node.countertopOverhang,
+            side: 'right',
+            siblingSpans,
+        });
+        // A side bar's knee wall sits flush on that end — no slab overhang there.
+        let leftOverhang = hasInternalLeftNeighbor || hasExternalLeftNeighbor || barEdge === 'left'
+            ? 0
+            : node.countertopOverhang;
+        let rightOverhang = hasInternalRightNeighbor || hasExternalRightNeighbor || barEdge === 'right'
+            ? 0
+            : node.countertopOverhang;
+        // A derived base leg mates back into the source run on its inner corner
+        // edge, so that edge should be flush instead of carrying the usual
+        // exposed countertop overhang. The source run stays flush there too.
+        if (cornerLink?.role === 'base-leg') {
+            if (cornerLink.side === 'right' && spanIndex === 0)
+                leftOverhang = 0;
+            if (cornerLink.side === 'left' && spanIndex === spans.length - 1)
+                rightOverhang = 0;
+        }
+        if (childBaseLegSides.has('left') && spanIndex === 0)
+            leftOverhang = 0;
+        if (childBaseLegSides.has('right') && spanIndex === spans.length - 1)
+            rightOverhang = 0;
+        const exposedLeft = spanIndex === 0 && !hasExternalLeftNeighbor && !hasInternalLeftNeighbor && barEdge !== 'left';
+        const exposedRight = spanIndex === spans.length - 1 &&
+            !hasExternalRightNeighbor &&
+            !hasInternalRightNeighbor &&
+            barEdge !== 'right';
+        return { leftOverhang, rightOverhang, exposedLeft, exposedRight };
+    });
+}
+/**
+ * X center for inserting a `width`-wide module on the given side of the
+ * anchor (or on the run's outer edge with no anchor). Returns null when a
+ * flush neighbor leaves no room on that side.
+ */
+export function sideInsertX({ anchorModule, modules, side, width, epsilon = RUN_ADJACENCY_EPSILON, }) {
+    if (modules.length === 0) {
+        return side === 'left' ? -width / 2 : width / 2;
+    }
+    if (!anchorModule) {
+        const edge = side === 'left' ? runMinX(modules) : runMaxX(modules);
+        return side === 'left' ? edge - width / 2 : edge + width / 2;
+    }
+    const selectedLeft = moduleMinX(anchorModule);
+    const selectedRight = moduleMaxX(anchorModule);
+    const siblings = modules.filter((module) => module.id !== anchorModule.id);
+    if (side === 'left') {
+        const nearestLeft = siblings
+            .map(moduleMaxX)
+            .filter((edge) => edge <= selectedLeft + epsilon)
+            .reduce((best, edge) => (best == null || edge > best ? edge : best), null);
+        if (nearestLeft != null && selectedLeft - nearestLeft < width - epsilon) {
+            return null;
+        }
+        return selectedLeft - width / 2;
+    }
+    const nearestRight = siblings
+        .map(moduleMinX)
+        .filter((edge) => edge >= selectedRight - epsilon)
+        .reduce((best, edge) => (best == null || edge < best ? edge : best), null);
+    if (nearestRight != null && nearestRight - selectedRight < width - epsilon) {
+        return null;
+    }
+    return selectedRight + width / 2;
+}
+/**
+ * Re-pack the run left-to-right after one module's width changes, keeping
+ * every module flush with its left neighbor. Returns per-module patches.
+ */
+export function reflowRunModules(modules, selectedId, selectedWidth) {
+    const sorted = sortRunModules(modules);
+    if (!sorted.some((module) => module.id === selectedId))
+        return [];
+    let nextLeft = runMinX(sorted);
+    return sorted.map((module) => {
+        const width = module.id === selectedId ? selectedWidth : module.width;
+        const position = [
+            nextLeft + width / 2,
+            module.position[1],
+            module.position[2],
+        ];
+        nextLeft += width;
+        return { id: module.id, position, width };
+    });
+}
+/** Full-run bounds in run-local frame (X along the run). */
+export function runLocalXExtent(modules) {
+    if (modules.length === 0)
+        return null;
+    const minX = runMinX(modules);
+    const maxX = runMaxX(modules);
+    return { minX, maxX, centerX: (minX + maxX) / 2, width: Math.max(0.01, maxX - minX) };
+}
+/** Rotate + translate a run-local point into the plan (level) frame. */
+export function runLocalToPlan(run, local) {
+    const cos = Math.cos(run.rotation);
+    const sin = Math.sin(run.rotation);
+    const [lx, ly, lz] = local;
+    return [
+        run.position[0] + lx * cos + lz * sin,
+        run.position[1] + ly,
+        run.position[2] - lx * sin + lz * cos,
+    ];
+}
+/** Inverse of {@link runLocalToPlan}. */
+export function planToRunLocal(run, planX, localY, planZ) {
+    const dx = planX - run.position[0];
+    const dz = planZ - run.position[2];
+    const cos = Math.cos(run.rotation);
+    const sin = Math.sin(run.rotation);
+    return [dx * cos - dz * sin, localY, dx * sin + dz * cos];
+}

package/dist/cabinet/run-ops.d.ts

@@ -0,0 +1,140 @@
+import { type AnyNode, type AnyNodeId, type CabinetModuleNode, type CabinetNode, type SceneApi } from '@pascal-app/core';
+/**
+ * Kind-owned cabinet run mutations, shared by the properties panel, the
+ * quick-action menu, and the placement tool. Everything routes through
+ * `SceneApi` so each caller (panel with `useScene`, actions with the
+ * registry's api) gets identical behavior — these used to be copy-pasted
+ * per surface and had already drifted (gap checks, hood support, revision
+ * scope).
+ */
+export declare const CABINET_BASE_WIDTH = 0.6;
+export declare const CABINET_WALL_DEPTH = 0.32;
+export declare const CABINET_WALL_CARCASS_HEIGHT = 0.72;
+export declare const CABINET_TALL_DEPTH = 0.58;
+export declare const CABINET_TALL_PLINTH_HEIGHT = 0.1;
+export declare const CABINET_TALL_CARCASS_HEIGHT = 2.07;
+export declare const CABINET_EDGE_EPSILON = 0.0001;
+export type CabinetEditableNode = CabinetNode | CabinetModuleNode;
+type CornerSide = 'left' | 'right';
+type CabinetRunStylePatch = Pick<Partial<CabinetNode>, 'frontStyle' | 'frontOverlay' | 'handleStyle' | 'handlePosition'>;
+export declare function cabinetMetadataRecord(metadata: CabinetEditableNode['metadata']): Record<string, unknown>;
+/**
+ * Deleting one member of an L-corner group removes ONLY that node (plus its
+ * normal descendants) — never the other corner runs. These patches keep the
+ * metadata links consistent afterwards:
+ *  - deleting a derived leg run → drop its id from the source module's
+ *    `cabinetCornerSourceLink.linkedRunIds` (drop the link when empty);
+ *  - deleting the source module → strip `cabinetCornerDerivedRun` from the
+ *    surviving legs so they become plain independent runs.
+ * Patches targeting nodes that are also being deleted are skipped by the
+ * store, so deleting the whole source run (subtree cascade) stays clean.
+ */
+export declare function cabinetCornerUnlinkPatchesOnDelete(node: CabinetNode | CabinetModuleNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): Array<{
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}>;
+/**
+ * A cabinet run is a grouping container — once its last child is deleted
+ * the empty run must go too, so no orphan group lingers in the scene graph
+ * or the persisted data. Children may be modules or derived corner leg
+ * runs (which position themselves relative to the run), so ANY survivor
+ * keeps the run alive. `pendingDeleteIds` covers multi-select deletes:
+ * siblings already part of the same gesture count as gone.
+ */
+export declare function cabinetEmptyRunCascadeDeleteIds(node: CabinetEditableNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>, pendingDeleteIds: ReadonlySet<AnyNodeId>): AnyNodeId[];
+/**
+ * Bump the run's layout revision — the geometryKey input that forces its
+ * composite geometry (spans, countertop, plinth) to re-flow when a child
+ * module changes in a way the run's own fields don't capture. Sibling runs
+ * are re-keyed separately by the adjacency watcher in `system.tsx`, so no
+ * level-wide sweep is needed here.
+ */
+export declare function bumpCabinetRunLayoutRevision(sceneApi: SceneApi, run: CabinetNode): void;
+export declare function runModuleBaseY(run: Pick<CabinetNode, 'showPlinth' | 'plinthHeight'>): number;
+export declare function totalCabinetHeight(node: Pick<CabinetEditableNode, 'showPlinth' | 'plinthHeight' | 'carcassHeight' | 'withCountertop' | 'countertopThickness'>): number;
+/** Y where a wall cabinet's bottom lands so its top aligns with a tall unit's top. */
+export declare function wallBottomHeightForTallAlignment(): number;
+/** Local Z offset that makes a shallower wall cabinet's back flush with its deeper base. */
+export declare function backAlignZ(baseDepth: number, wallDepth: number): number;
+export declare function wallChildOf(module: CabinetModuleNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): CabinetModuleNode | null;
+export declare function resolveCabinetType(module: CabinetModuleNode, run?: CabinetNode): 'base' | 'tall';
+export declare function cabinetModulesForRun(run: CabinetNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): CabinetModuleNode[];
+export declare function cornerSourceModulesForRun(run: CabinetNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): CabinetModuleNode[];
+export declare function cornerLinkedSourceModuleForRun(run: CabinetNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): CabinetModuleNode | null;
+export declare function cornerStyleSourceForRun(run: CabinetNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+} | null;
+export declare function syncCornerStyleGroupFromRun({ run, patch, sceneApi, }: {
+    run: CabinetNode;
+    patch: CabinetRunStylePatch;
+    sceneApi: SceneApi;
+}): boolean;
+export declare function previewCornerAdditionLayout({ module, run, nodes, side, }: {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>;
+    side: CornerSide;
+}): {
+    connectedWidth: number;
+    sourceWidth: number;
+} | null;
+export declare function syncCornerRunsFromSourceModule({ module, run, sceneApi, }: {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+}): void;
+/**
+ * Insert a new base module flush against the anchor's side (or the run's
+ * outer edge with no anchor). Gap-checked — returns null when a flush
+ * neighbor leaves no room for a standard-width unit.
+ */
+export declare function planCabinetModuleSideAddition({ anchorModule, nodes, run, side, }: {
+    anchorModule: CabinetModuleNode | null;
+    nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>;
+    run: CabinetNode;
+    side: 'left' | 'right';
+}): CabinetModuleNode | null;
+export declare function addCabinetModuleSide({ anchorModule, run, sceneApi, side, }: {
+    anchorModule: CabinetModuleNode | null;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+    side: 'left' | 'right';
+}): AnyNodeId | null;
+/**
+ * Spawn an L corner off one open end of a base run: a perpendicular base leg
+ * with a corner pocket filler plus cabinet, a matching wall leg, and a short
+ * wall bridge above the source run's corner cabinet so the top corner doesn't
+ * read empty.
+ */
+export declare function addCornerRun({ module, run, sceneApi, side, }: {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+    side: 'left' | 'right';
+}): AnyNodeId | null;
+/**
+ * Nest a wall cabinet (or chimney hood) above a base module. Returns the new
+ * node id, or null when the module already carries one / isn't a base unit.
+ */
+export declare function addWallChildAbove({ kind, module, run, sceneApi, openSide, }: {
+    kind: 'cabinet' | 'hood';
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+    openSide?: CabinetModuleNode['openSide'];
+}): AnyNodeId | null;
+/** Convert a base module to a tall unit (deletes any nested wall cabinet). */
+export declare function switchCabinetToTall({ module, run, sceneApi, }: {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+}): boolean;
+/** Convert a tall module back to a base unit matching the run's dimensions. */
+export declare function switchCabinetToBase({ module, run, sceneApi, }: {
+    module: CabinetModuleNode;
+    run: CabinetNode;
+    sceneApi: SceneApi;
+}): boolean;
+export {};
+//# sourceMappingURL=run-ops.d.ts.map

package/dist/cabinet/run-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-ops.d.ts","sourceRoot":"","sources":["../../src/cabinet/run-ops.ts"],"names":[],"mappings":"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"}