@pascal-app/nodes 0.1.1

package/dist/cabinet/continuous-placement.js

@@ -0,0 +1,110 @@
+import { planToRunLocal, runLocalToPlan } from './run-layout';
+import { CABINET_BASE_WIDTH } from './run-ops';
+const MIN_END_MODULE_WIDTH = 0.1;
+export function isForcePlacementEvent(event) {
+    const native = event.nativeEvent;
+    return native?.altKey === true;
+}
+// Fill a span with standard-width modules; the remainder becomes a narrower
+// end module (dropped entirely below MIN_END_MODULE_WIDTH).
+export function fillCabinetContinuousSpan(length) {
+    const full = Math.max(1, Math.floor((length + 1e-6) / CABINET_BASE_WIDTH));
+    const widths = new Array(full).fill(CABINET_BASE_WIDTH);
+    const remainder = length - full * CABINET_BASE_WIDTH;
+    if (remainder >= MIN_END_MODULE_WIDTH)
+        widths.push(remainder);
+    return widths;
+}
+export function planCabinetContinuousStretch({ anchor, previewWidth, rawPlanPosition, }) {
+    const runLike = { position: anchor.position, rotation: anchor.yaw };
+    const localX = planToRunLocal(runLike, rawPlanPosition[0], 0, rawPlanPosition[2])[0];
+    const dir = anchor.forcedDirection ?? (localX >= 0 ? 1 : -1);
+    const firstWidth = anchor.leadingWidth ?? previewWidth;
+    const halfFirst = firstWidth / 2;
+    const hasLeadingWidth = anchor.leadingWidth != null;
+    const projected = anchor.forcedDirection ? Math.max(0, localX * dir) : Math.abs(localX);
+    const minTotalLength = hasLeadingWidth ? firstWidth + previewWidth : firstWidth;
+    const length = Math.max(projected + halfFirst, minTotalLength);
+    const trailingLength = Math.max(0, length - firstWidth);
+    const trailingWidths = trailingLength <= 1e-6 ? [] : fillCabinetContinuousSpan(trailingLength);
+    const widths = [firstWidth, ...trailingWidths];
+    const total = widths.reduce((sum, width) => sum + width, 0);
+    let cum = 0;
+    const modules = widths.map((width) => {
+        const x = dir * (cum + width / 2 - halfFirst);
+        cum += width;
+        return { x, width };
+    });
+    return {
+        modules,
+        length: total,
+        centerLocalX: dir * (total / 2 - halfFirst),
+        direction: dir,
+    };
+}
+export function cabinetStretchExitSide(stretch) {
+    return stretch.direction === 1 ? 'right' : 'left';
+}
+export function cabinetStretchEndLocalX(stretch, previewWidth) {
+    return stretch.direction * (stretch.length - previewWidth / 2);
+}
+export function createCabinetContinuousContinuation({ anchor, previewDepth, previewWidth, stretch, }) {
+    const endLocalX = cabinetStretchEndLocalX(stretch, previewWidth);
+    const hingePosition = runLocalToPlan({ position: anchor.position, rotation: anchor.yaw }, [
+        endLocalX,
+        0,
+        0,
+    ]);
+    const straightAnchor = {
+        position: runLocalToPlan({ position: anchor.position, rotation: anchor.yaw }, [
+            endLocalX + stretch.direction * (previewWidth / 2),
+            0,
+            0,
+        ]),
+        yaw: anchor.yaw,
+        snappedToWall: anchor.snappedToWall,
+        wallSurfaceNormal: anchor.wallSurfaceNormal,
+    };
+    const exitSide = cabinetStretchExitSide(stretch);
+    const sourceAxis = [Math.cos(anchor.yaw), -Math.sin(anchor.yaw)];
+    const corner = runLocalToPlan({ position: anchor.position, rotation: anchor.yaw }, [
+        endLocalX,
+        0,
+        -previewDepth / 2,
+    ]);
+    const sign = exitSide === 'right' ? 1 : -1;
+    const shiftedCorner = [
+        corner[0] + sign * previewDepth * sourceAxis[0],
+        corner[2] + sign * previewDepth * sourceAxis[1],
+    ];
+    const yaw = exitSide === 'right' ? anchor.yaw - Math.PI / 2 : anchor.yaw + Math.PI / 2;
+    const turnAnchor = {
+        position: runLocalToPlan({
+            position: [shiftedCorner[0], anchor.position[1], shiftedCorner[1]],
+            rotation: yaw,
+        }, [previewDepth / 2, 0, previewDepth / 2]),
+        yaw,
+        snappedToWall: false,
+        forcedDirection: 1,
+        leadingWidth: previewDepth,
+    };
+    return {
+        hingePosition,
+        sourceYaw: anchor.yaw,
+        sourceDirection: stretch.direction,
+        straightAnchor,
+        turnAnchor,
+    };
+}
+export function chooseCabinetContinuousAnchor(continuation, rawPlanPosition) {
+    const [localX, , localZ] = planToRunLocal({ position: continuation.hingePosition, rotation: continuation.sourceYaw }, rawPlanPosition[0], 0, rawPlanPosition[2]);
+    const forward = localX * continuation.sourceDirection;
+    const lateral = Math.abs(localZ);
+    return forward >= lateral ? continuation.straightAnchor : continuation.turnAnchor;
+}
+export function resolveCabinetContinuousValidity(result, forcePlace) {
+    return forcePlace ? { conflictIds: [], valid: true } : result;
+}
+export function isCabinetContinuousFollowUpClick(clickCount) {
+    return clickCount >= 2;
+}

package/dist/cabinet/cooktop-flame.d.ts

@@ -0,0 +1,14 @@
+import { BufferGeometry } from 'three';
+export declare const COOKTOP_FLAME_COUNT = 22;
+export declare const COOKTOP_FLAME_SEG = 12;
+export declare const COOKTOP_FLAME_RAD = 5;
+export type CooktopFlameSeed = {
+    phase: number;
+    speed: number;
+    height: number;
+    reach: number;
+};
+export declare function cooktopFlameSeed(index: number): CooktopFlameSeed;
+export declare function createCooktopFlameGeometry(): BufferGeometry;
+export declare function updateCooktopFlameTube(positions: Float32Array, t: number, seed: CooktopFlameSeed, burnerR: number): void;
+//# sourceMappingURL=cooktop-flame.d.ts.map

package/dist/cabinet/cooktop-flame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cooktop-flame.d.ts","sourceRoot":"","sources":["../../src/cabinet/cooktop-flame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAqC,MAAM,OAAO,CAAA;AAS1F,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,eAAO,MAAM,iBAAiB,KAAK,CAAA;AACnC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAElC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAOhE;AA6BD,wBAAgB,0BAA0B,IAAI,cAAc,CA2B3D;AAUD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,YAAY,EACvB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,QA+ChB"}

package/dist/cabinet/cooktop-flame.js

@@ -0,0 +1,115 @@
+import { BufferAttribute, BufferGeometry, CatmullRomCurve3, Sphere, Vector3 } from 'three';
+// Real gas-burner flames are a ring of small jets: each one leaves its port,
+// sweeps outward as it rises, then bends back up at the tip. Most of the body
+// is blue/cyan; only the top ~25% picks up the orange-yellow nip. Each flame
+// is a tapered tube along a CatmullRom spine, vertex-coloured along its
+// length; per frame the spine control points wobble + breathe so the flame
+// licks and flickers without shaders.
+export const COOKTOP_FLAME_COUNT = 22;
+export const COOKTOP_FLAME_SEG = 12;
+export const COOKTOP_FLAME_RAD = 5;
+export function cooktopFlameSeed(index) {
+    return {
+        phase: (index * 1.37) % (Math.PI * 2),
+        speed: 0.45 + ((index * 7) % 5) * 0.06,
+        height: 0.85 + ((index * 3) % 5) * 0.07 + (index % 2) * 0.12,
+        reach: 0.92 + ((index * 11) % 4) * 0.05,
+    };
+}
+const C_DEEP_BLUE = [0.15, 0.45, 1.7];
+const C_BRIGHT_CYAN = [0.55, 1.1, 1.95];
+const C_ORANGE = [1.85, 0.7, 0.18];
+const C_YELLOW = [2.05, 1.65, 0.4];
+function lerpRGB(a, b, k, out, offset) {
+    out[offset] = a[0] + (b[0] - a[0]) * k;
+    out[offset + 1] = a[1] + (b[1] - a[1]) * k;
+    out[offset + 2] = a[2] + (b[2] - a[2]) * k;
+}
+// Colour at curve parameter u (0 = port, 1 = tip): blue body, narrow swing
+// to orange, yellow only at the very tip.
+function flameColourAt(u, out, offset) {
+    if (u < 0.45)
+        lerpRGB(C_DEEP_BLUE, C_BRIGHT_CYAN, u / 0.45, out, offset);
+    else if (u < 0.75)
+        lerpRGB(C_BRIGHT_CYAN, C_ORANGE, (u - 0.45) / 0.3, out, offset);
+    else
+        lerpRGB(C_ORANGE, C_YELLOW, (u - 0.75) / 0.25, out, offset);
+}
+// Pre-allocated tube geometry — positions are mutated in place every frame;
+// colours depend only on u so they are written once here.
+export function createCooktopFlameGeometry() {
+    const vCount = (COOKTOP_FLAME_SEG + 1) * (COOKTOP_FLAME_RAD + 1);
+    const positions = new Float32Array(vCount * 3);
+    const colors = new Float32Array(vCount * 3);
+    for (let i = 0; i <= COOKTOP_FLAME_SEG; i += 1) {
+        const u = i / COOKTOP_FLAME_SEG;
+        for (let j = 0; j <= COOKTOP_FLAME_RAD; j += 1) {
+            flameColourAt(u, colors, ((COOKTOP_FLAME_RAD + 1) * i + j) * 3);
+        }
+    }
+    const indices = [];
+    for (let i = 1; i <= COOKTOP_FLAME_SEG; i += 1) {
+        for (let j = 1; j <= COOKTOP_FLAME_RAD; j += 1) {
+            const a = (COOKTOP_FLAME_RAD + 1) * (i - 1) + (j - 1);
+            const b = (COOKTOP_FLAME_RAD + 1) * i + (j - 1);
+            const c = (COOKTOP_FLAME_RAD + 1) * i + j;
+            const d = (COOKTOP_FLAME_RAD + 1) * (i - 1) + j;
+            indices.push(a, b, d, b, c, d);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new BufferAttribute(positions, 3));
+    geometry.setAttribute('color', new BufferAttribute(colors, 3));
+    geometry.setIndex(indices);
+    // Static generous bound — flames are a few cm; skips per-frame recompute.
+    geometry.boundingSphere = new Sphere(new Vector3(0.02, 0.03, 0), 0.12);
+    return geometry;
+}
+// Scratch objects reused across calls so the per-frame allocator stays quiet.
+const _spineVecs = [new Vector3(), new Vector3(), new Vector3(), new Vector3(), new Vector3()];
+const _curve = new CatmullRomCurve3(_spineVecs, false, 'catmullrom', 0.5);
+const _pt = new Vector3();
+// Rebuild a flame tube's vertices for time `t`. Built in the flame's LOCAL
+// frame — the parent group sits at the port and is rotated so local +X
+// points outward from the burner centre.
+export function updateCooktopFlameTube(positions, t, seed, burnerR) {
+    const tt = t * seed.speed + seed.phase;
+    // Compact gas jet (3-4 cm): the dominant motion is this breathing factor —
+    // the tongue bobs like a real burner flame rather than strobing.
+    const breathe = 0.93 + 0.09 * Math.sin(tt * 2.6) + 0.03 * Math.sin(tt * 5.1);
+    const length = 0.038 * seed.height * breathe;
+    const reach = length * 0.4 * seed.reach;
+    // Tiny spine perturbations so the hook shape holds and just trembles.
+    const wobX = Math.sin(tt * 2.1) * 0.0008;
+    const wobY = Math.cos(tt * 2.4 + 0.7) * 0.0015;
+    const sway = Math.sin(tt * 1.9) * 0.0022;
+    _spineVecs[0].set(0, 0, 0);
+    _spineVecs[1].set(reach * 0.28 + wobX, length * 0.2, sway * 0.25);
+    _spineVecs[2].set(reach * 0.62, length * 0.45 + wobY, sway * 0.55);
+    _spineVecs[3].set(reach * 0.55 - wobX, length * 0.75, sway * 0.35);
+    _spineVecs[4].set(reach * 0.35, length * 0.98 + wobY, sway * 0.08);
+    _curve.points = _spineVecs;
+    _curve.updateArcLengths();
+    const frames = _curve.computeFrenetFrames(COOKTOP_FLAME_SEG, false);
+    // Slim at the port, slight mid-body bulge, sharp tip — the teardrop
+    // silhouette of a real gas jet. Scales with the burner head.
+    const baseR = burnerR * 0.11;
+    const tipR = burnerR * 0.018;
+    for (let i = 0; i <= COOKTOP_FLAME_SEG; i += 1) {
+        const u = i / COOKTOP_FLAME_SEG;
+        _curve.getPointAt(u, _pt);
+        const N = frames.normals[i];
+        const B = frames.binormals[i];
+        const taper = baseR * (1 - u) + tipR * u + Math.sin(u * Math.PI) * burnerR * 0.018;
+        const baseV = (COOKTOP_FLAME_RAD + 1) * i;
+        for (let j = 0; j <= COOKTOP_FLAME_RAD; j += 1) {
+            const ang = (j / COOKTOP_FLAME_RAD) * Math.PI * 2;
+            const sn = Math.sin(ang);
+            const cs = -Math.cos(ang);
+            const vIdx = (baseV + j) * 3;
+            positions[vIdx] = _pt.x + taper * (cs * N.x + sn * B.x);
+            positions[vIdx + 1] = _pt.y + taper * (cs * N.y + sn * B.y);
+            positions[vIdx + 2] = _pt.z + taper * (cs * N.z + sn * B.z);
+        }
+    }
+}

package/dist/cabinet/definition.d.ts

@@ -0,0 +1,26 @@
+import type { AnyNode, AnyNodeId, CabinetNode as CabinetNodeType, FloorPlacedFootprint, NodeDefinition, SceneApi } from '@pascal-app/core';
+import { CabinetModuleNode, CabinetNode } from './schema';
+export declare function cabinetFloorPlacedFootprints(node: CabinetNodeType, nodes?: Readonly<Record<AnyNodeId, AnyNode>>): FloorPlacedFootprint[];
+export type CabinetRunFootprint = {
+    parentId: AnyNodeId | null;
+    x: number;
+    z: number;
+    reach: number;
+};
+export declare function cabinetRunFootprint(run: CabinetNodeType, nodes: Readonly<Record<AnyNodeId, AnyNode>>): CabinetRunFootprint;
+/**
+ * Re-key sibling cabinet runs whose countertop join could be affected by a
+ * run that moved / resized / re-flowed. A run's overhang trims against
+ * adjacent sibling runs (`siblingCabinetSpansInRunLocal`), but a neighbor's
+ * own `geometryKey` doesn't change when THIS run moves — marking it dirty
+ * alone would be swallowed by the geometry system's key-skip cache. Bumping
+ * `cabinetAdjacencyRevision` (folded into the run geometryKey) both dirties
+ * and re-keys it. History is paused: the counter is derived presentation
+ * state, and an undo of the triggering move re-fires the watcher anyway.
+ */
+export declare function bumpCabinetRunsNear(sceneApi: SceneApi, footprints: readonly CabinetRunFootprint[], moverIds: ReadonlySet<string>): void;
+/** Inputs of a run that can change a NEIGHBOR's countertop join. */
+export declare function cabinetRunNeighborSignature(run: CabinetNodeType): string;
+export declare const cabinetDefinition: NodeDefinition<typeof CabinetNode>;
+export declare const cabinetModuleDefinition: NodeDefinition<typeof CabinetModuleNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cabinet/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAET,WAAW,IAAI,eAAe,EAG9B,oBAAoB,EAEpB,cAAc,EACd,QAAQ,EACT,MAAM,kBAAkB,CAAA;AA2BzB,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAiKzD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,eAAe,EACrB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,oBAAoB,EAAE,CAcxB;AAmGD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAA;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,mBAAmB,CAWrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,QAgD9B;AAED,oEAAoE;AACpE,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAaxE;AA6dD,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CA2LhE,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,OAAO,iBAAiB,CAmK5E,CAAA"}