Wall

import { Wall } from '@opengeometry/floorkit';

import { Wall, WallMaterial, Floorkit } from '@opengeometry/floorkit';

async function example(wasmURL: string): Promise<void> {
  await new Floorkit().setupOpenGeometry(wasmURL);
  const wall = new Wall({
    labelName: 'Partition',
    axis: { kind: 'line', start: [0, 0, 0], end: [5, 0, 0] },
    thickness: 0.2,
    height: 3,
    baseElevation: 0,
    locationLine: 'centre',
    locationOffset: 0,
    material: WallMaterial.CONCRETE,
    color: 0xcccccc,
    priority: 0,
    joins: { start: { allow: true }, end: { allow: true } },
  });
  try {
    wall.setOPConfig({ height: 3.2 });
    console.log(wall.getOPConfig(), wall.toDrawing('top'));
  } finally {
    wall.dispose();
  }
}

constructor(options: WallOptions);

static editableSchema(): OPEditableSchema;

refreshOutline(solids?: readonly AnalyticSolid[]): void;

anchorSpace(): "world";

getEditAnchors(): EditAnchor[];

applyEditAnchor(id: string, position: [
    number,
    number,
    number
], snapRadius?: number): void;

beginOpeningGesture(): void;

beginWallDragPreview(): void;

endWallDragPreview(): void;

commitOpeningCuts(): void;

prepareOpeningCuts(): {
    commit: () => void;
    rollback: () => void;
};

abortOpeningGesture(): void;

getHostedOpenings(): HostedOpening[];

attachDoor(opening: Door, placement?: WallHostPlacement): void;

attachWindow(opening: Window, placement?: WallHostPlacement): void;

attachWallOpening(opening: WallOpening, placement?: WallHostPlacement): void;

openingFit(input: WallOpeningFitInput): WallOpeningFit;

attachOpening(opening: HostedOpening, placement?: WallHostPlacement): void;

detachOpening(openingOrId: HostedOpening | string): void;

moveOpening(openingOrId: HostedOpening | string, placement: WallHostPlacement): void;

getOPConfig(): WallOptions;

getNetworkConfig(): Readonly<WallOptions>;

restoreConfig(config: WallOptions): void;

beginEdit(): void;

endEdit(): {
    undo: () => void;
    redo: () => void;
} | undefined;

deleteFromNetwork(): {
    undo: () => void;
    redo: () => void;
} | undefined;

setOPConfig(update: Partial<WallOptions>): void;

bind(network: WallNetwork | undefined): void;

assignAxis(axis: WallOptions["axis"]): void;

setResolvedFootprint(footprint: WallFootprint): boolean;

toDrawing(view: PlanExportView): DrawingPrimitive[];

getExportRoots(view: PlanExportView): AnalyticSolid[];

getOpeningDiagnostics(junctions?: readonly Junction[], reportPendingCuts?: boolean): JunctionDiagnostic[];

move(delta: Vec3): void;

rotate(angleDeg: number, axis?: Vec3, anchor?: Vec3): void;

dispose(): void;

interface WallOptions extends HasPropertySets {
  ogid?: string;
  labelName: string;
  axis: WallAxis;
  thickness: number;
  height: number;
  baseElevation: number;
  locationLine: LocationLine;
  locationOffset: number;
  material: WallMaterial | string;
  color: number;
  priority: number;
  joins: {
    start: WallEndJoin;
    end: WallEndJoin;
  };
}

interface WallFootprint {
  rings: FootprintRing[];
}

type HostedOpening = Door | Window | WallOpening;

interface WallHostPlacement {
  offset?: number;
  baseHeight?: number;
}

interface WallOpeningFitInput {
  station: number;
  width: number;
  bottom: number;
  top: number;
  openingId: string;
  avoidTSeams?: boolean;
}

interface WallOpeningFit {
  fits: boolean;
  reasons: WallOpeningFitReason[];
  nearestStation: number | null;
  fitRange: {
    start: number;
    end: number;
  } | null;
}

interface Junction {
  key: string;
  kind: JunctionKind;
  point: XZ;
  members: Array<{
    wallId: string;
    at: WallEnd | 'path';
    station?: number;
  }>;
  order: string[];
  type: JoinType;
  caps: Record<string, FootprintEdge[]>;
  diagnostics: JunctionDiagnostic[];
}

type JunctionDiagnostic =
  | {
      code: 'beveled' | 'unresolvable' | 'absorbed' | 'disconnected' | 'detached' | 'clamped';
      junctionKey: string;
      wallIds: string[];
    }
  | {
      code: 'clash-overlap' | 'self-loop';
      wallIds: string[];
    }
  | {
      code: 'opening-over-junction' | 'opening-boolean-unavailable';
      wallId: string;
      openingId: string;
    }
  | {
      code: 'opening-outside-net-run' | 'opening-rejected-at-crossing';
      wallId: string;
      openingId: string;
      fit: WallOpeningFit;
    };

type Vec3 = [number, number, number];

type LocationLine = 'centre' | 'left' | 'right';

enum WallMaterial {
  CONCRETE = 'CONCRETE',
  BRICK = 'BRICK',
  WOOD = 'WOOD',
  GLASS = 'GLASS',
  OTHER = 'OTHER',
}

interface WallEndJoin {
  allow: boolean;
  type?: JoinType;
}

interface FootprintRing {
  edges: FootprintEdge[];
  holes?: FootprintEdge[][];
}

type WallOpeningFitReason =
  | 'too-wide'
  | 'x-crossing'
  | 'outside-net-run'
  | 'outside-height'
  | 't-junction';

type JunctionKind = 'L' | 'continuation' | 'T' | 'X' | 'Y' | 'multi' | 'free';

type FootprintEdge =
  | {
      kind: 'line';
      from: XZ;
      to: XZ;
      role: EdgeRole;
    }
  | {
      kind: 'arc';
      center: XZ;
      radius: number;
      from: number;
      to: number;
      ccw: boolean;
      role: EdgeRole;
    };

type EdgeRole = 'face' | 'cap' | 'seam';