e618175bba
Wholesale swap of packages/{core,viewer,editor,mcp} and apps/editor with the
versions from the private editor repo, which is the production source of truth.
Setup changes:
- packages/{core,viewer,editor} versions held at 0.7.0 baseline (matching
the most recent published release) so a bump=minor publishes 0.8.0
- packages/mcp held at 0.1.1 (never published; first publish will go through
the new release.yml flow)
- peerDependencies and devDependencies for inter-package @pascal-app/*
references pinned to ^0.7.0 instead of '*' / 'workspace:*' so they are
valid for npm consumers
- Root package.json: TypeScript bumped to 6.0.2, added overrides for
@types/react, @types/react-dom, @types/three to prevent JSX namespace
fragmentation across the workspace
- release.yml extended to also publish editor and mcp; 'both' option renamed
to 'all'; added a sync step that updates inter-package peerDeps/devDeps to
match the new versions on every bump (so viewer/editor/mcp tarballs always
reference the version of core they were built against)
- Root scripts gained release:editor and release:mcp shortcuts
Verification:
- bun install --frozen-lockfile is consistent
- packages/{core,viewer,mcp} build cleanly, dist/index.d.ts emitted
- packages/editor check-types reports 21 pre-existing errors, identical to
what private-editor currently reports
Open PRs against editor-v2 will need rebasing/conflict resolution.
106 lines
3.3 KiB
TypeScript
106 lines
3.3 KiB
TypeScript
import dedent from 'dedent'
|
|
import { z } from 'zod'
|
|
import { BaseNode, nodeType, objectId } from '../base'
|
|
import type { MaterialSchema as MaterialSchemaType } from '../material'
|
|
import { MaterialSchema } from '../material'
|
|
import { RoofSegmentNode } from './roof-segment'
|
|
|
|
export type RoofSurfaceMaterialRole = 'top' | 'edge' | 'wall'
|
|
export type RoofSurfaceMaterialSpec = {
|
|
material?: MaterialSchemaType
|
|
materialPreset?: string
|
|
}
|
|
|
|
export const RoofNode = BaseNode.extend({
|
|
id: objectId('roof'),
|
|
type: nodeType('roof'),
|
|
material: MaterialSchema.optional(),
|
|
materialPreset: z.string().optional(),
|
|
topMaterial: MaterialSchema.optional(),
|
|
topMaterialPreset: z.string().optional(),
|
|
edgeMaterial: MaterialSchema.optional(),
|
|
edgeMaterialPreset: z.string().optional(),
|
|
wallMaterial: MaterialSchema.optional(),
|
|
wallMaterialPreset: z.string().optional(),
|
|
position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
|
|
// Rotation around Y axis in radians
|
|
rotation: z.number().default(0),
|
|
// Child roof segment IDs
|
|
children: z.array(RoofSegmentNode.shape.id).default([]),
|
|
}).describe(
|
|
dedent`
|
|
Roof node - a container for roof segments.
|
|
Acts as a group that holds one or more RoofSegmentNodes.
|
|
When not being edited, segments are visually combined into a single solid.
|
|
- position: center position of the roof group
|
|
- rotation: rotation around Y axis
|
|
- children: array of RoofSegmentNode IDs
|
|
`,
|
|
)
|
|
|
|
export type RoofNode = z.infer<typeof RoofNode>
|
|
|
|
function getLegacyRoofSurfaceMaterial(node: RoofNode): RoofSurfaceMaterialSpec {
|
|
return {
|
|
material: node.material,
|
|
materialPreset: node.materialPreset,
|
|
}
|
|
}
|
|
|
|
export function getEffectiveRoofSurfaceMaterial(
|
|
node: RoofNode,
|
|
role: RoofSurfaceMaterialRole,
|
|
): RoofSurfaceMaterialSpec {
|
|
if (role === 'top') {
|
|
if (node.topMaterial !== undefined || typeof node.topMaterialPreset === 'string') {
|
|
return {
|
|
material: node.topMaterial,
|
|
materialPreset:
|
|
typeof node.topMaterialPreset === 'string' ? node.topMaterialPreset : undefined,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (role === 'edge') {
|
|
if (node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string') {
|
|
return {
|
|
material: node.edgeMaterial,
|
|
materialPreset:
|
|
typeof node.edgeMaterialPreset === 'string' ? node.edgeMaterialPreset : undefined,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (role === 'wall') {
|
|
if (node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string') {
|
|
return {
|
|
material: node.wallMaterial,
|
|
materialPreset:
|
|
typeof node.wallMaterialPreset === 'string' ? node.wallMaterialPreset : undefined,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (role === 'edge') {
|
|
if (node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string') {
|
|
return {
|
|
material: node.wallMaterial,
|
|
materialPreset:
|
|
typeof node.wallMaterialPreset === 'string' ? node.wallMaterialPreset : undefined,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (role === 'wall') {
|
|
if (node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string') {
|
|
return {
|
|
material: node.edgeMaterial,
|
|
materialPreset:
|
|
typeof node.edgeMaterialPreset === 'string' ? node.edgeMaterialPreset : undefined,
|
|
}
|
|
}
|
|
}
|
|
|
|
return getLegacyRoofSurfaceMaterial(node)
|
|
}
|