WallNetwork

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

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

async function example(wasmURL: string): Promise<void> {
  await new Floorkit().setupOpenGeometry(wasmURL);
  const network = new WallNetwork({ defaultJoin: 'miter' });
  try {
    const walls = network.addPolyline(
      [
        [0, 0, 0],
        [5, 0, 0],
        [5, 0, 4],
      ],
      {
        labelName: 'Perimeter',
        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 } },
      },
    );
    const report = network.resolve();
    console.log(report.junctions, report.diagnostics);
    console.log(walls.map((wall) => wall.toDrawing('top')));
  } finally {
    network.dispose();
  }
}

constructor(options?: Partial<WallNetworkOptions>);

subscribeInvalidation(callback: (changed: readonly string[]) => void): () => void;

syncArcConfigEndpoints(wallId: string, axis: WallAxis): void;

beginEdit(): void;

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

atomicModelEdit<T>(edit: () => T): T;

invalidateWall(id: string, diagnostics?: JunctionDiagnostic[], extraChanged?: string[]): void;

snapAxisPoint(cursor: XZ, radius: number, origin?: XZ): {
    point: XZ;
    kind: "endpoint" | "midpoint" | "perpendicular";
} | undefined;

snapEndPoint(wallOrId: Wall | string, end: WallEnd, cursor: XZ, radius: number): XZ;

nearestWall(point: XZ, maxDistance: number): {
    wall: Wall;
    station: number;
    distance: number;
} | undefined;

outlineNeighbors(wall: Wall): Wall[];

lastResolveReport(): ResolveReport;

junctionsOfWall(wallId: string): readonly Junction[];

openingDiagnostics(): Extract<JunctionDiagnostic, {
    openingId: string;
}>[];

isSplitCrossingWall(wallId: string, junctions?: readonly Junction[]): boolean;

tSeamStations(host: Wall, junctions?: readonly Junction[]): {
    start: number;
    end: number;
}[];

openingJunctionDiagnostics(host: Wall, openingId: string, bounds: {
    startAlongWall: number;
    endAlongWall: number;
}, junctions?: readonly Junction[]): JunctionDiagnostic[];

registerOpening(opening: Door | Window | WallOpening, point: XZ, maxDistance: number): {
    undo: () => void;
    redo: () => void;
} | undefined;

beginHostedOpeningEdit(opening: HostedOpening): void;

previewHostedOpeningEdit(opening: HostedOpening, position: Vec3, snapRadius: number): void;

commitHostedOpeningEdit(opening: HostedOpening): {
    undo: () => void;
    redo: () => void;
} | undefined;

rehostOpening(opening: Door | Window | WallOpening, point: XZ, maxDistance: number): {
    undo: () => void;
    redo: () => void;
} | undefined;

add(wall: Wall): Wall;

addArc(axis: Extract<WallAxis, {
    kind: "circularArc";
}>, options: Omit<WallOptions, "axis" | "ogid">, id?: string): Wall;

addPolyline(points: readonly Vec3[], options: Omit<WallOptions, "axis" | "ogid">, ids?: readonly string[], resolve?: boolean): Wall[];

replaceSavedWalls(saved: {
    runs: readonly {
        points: readonly Vec3[];
        options: Omit<WallOptions, 'axis' | 'ogid'>;
        ids: readonly string[];
    }[];
    options: Partial<WallNetworkOptions> | undefined;
}, placed?: (walls: readonly Wall[]) => void): void;

setJoin(junctionKey: string, type: JoinType, order?: string[]): ResolveReport;

disallowJoin(wallOrId: Wall | string, end: WallEnd, disallow?: boolean): void;

remove(wallOrId: Wall | string): void;

moveEnd(wallOrId: Wall | string, end: WallEnd, point: XZ): ResolveReport;

translateWall(wallOrId: Wall | string, delta: XZ): ResolveReport;

resolve(dirtyWallIds?: ReadonlySet<string>): ResolveReport;

restoreDetachedFaceTrims(trims: readonly WallDetachedFaceTrim[]): void;

toModel(): WallNetworkModel;

static fromModel(model: WallNetworkModel): WallNetwork;

dispose(): void;

interface WallNode {
  id: string;
  point: [number, number];
  ends: WallEndRef[];
}

interface WallConstraint extends WallEndRef {
  hostWallId: string;
  station: number;
}

class Event<T> {
  add(
    handler: T extends void
      ? {
          (): void;
        }
      : {
          (data: T): void;
        },
  ): void;
  remove(
    handler: T extends void
      ? {
          (): void;
        }
      : {
          (data: T): void;
        },
  ): void;
  trigger: (data?: T) => void;
  reset(): void;
}

interface ResolveReport {
  changed: string[];
  junctions: Junction[];
  diagnostics: JunctionDiagnostic[];
}

interface WallNetworkOptions {
  joinTolerance: number;
  defaultJoin: JoinType;
  miterLimit: number;
  autoJoin: boolean;
}

type WallAxis =
  | {
      kind: 'line';
      start: Vec3;
      end: Vec3;
    }
  | {
      kind: 'circularArc';
      center: Vec3;
      radius: number;
      startAngle: number;
      sweepAngle: number;
    };

type XZ = {
  x: number;
  z: number;
};

type WallEnd = 'start' | 'end';

type HostedOpening = Door | Window | WallOpening;

type JoinType = 'miter' | 'butt' | 'squareOff';

interface WallDetachedFaceTrim extends WallEndRef {
  hostWallId: string;
  source?: 'T' | 'X';
}

interface WallNetworkModel {
  walls: WallOptions[];
  nodes: WallNode[];
  constraints: WallConstraint[];
  detachedFaceTrims?: WallDetachedFaceTrim[];
  joinOverrides: WallJoinOverride[];
  options: WallNetworkOptions;
}

interface WallEndRef {
  wallId: string;
  end: WallEnd;
}

interface WallJoinOverride {
  junctionKey: string;
  type?: JoinType;
  order?: string[];
}