OpenElement

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

import { OpenElement, ElementType, Floorkit } from '@opengeometry/floorkit';

async function example(wasmURL: string): Promise<void> {
  await new Floorkit().setupOpenGeometry(wasmURL);
  const asset = new OpenElement({
    version: 1,
    id: 'equipment',
    labelName: 'Equipment',
    type: ElementType.FURNITURE,
    dimensions: { width: 1, depth: 0.6, height: 0.9 },
    profileView: {
      elements: [
        {
          id: 'footprint',
          kind: 'polygon',
          vertices: [
            [-0.5, -0.3],
            [0.5, -0.3],
            [0.5, 0.3],
            [-0.5, 0.3],
          ],
        },
      ],
    },
    modelView: {
      elements: [
        { id: 'body', kind: 'cuboid', center: [0, 0.45, 0], width: 1, depth: 0.6, height: 0.9 },
      ],
    },
  });
  try {
    asset.updateNodeProperty('body', 'modelView', 'height', 1.1);
    console.log(asset.getControlSchema(), asset.getOPBuffer());
  } finally {
    asset.dispose();
  }
}

constructor(config?: OpenElementInput);

static parseBuffer(buffer: string): OpenElementDefinition;

static normalizeDefinition(definition: unknown): OpenElementDefinition;

getOPBuffer(): string;

getAnchorDefinition(anchorId: string): AnchorDefinition | undefined;

getAnchorMatrix(anchorId: string): THREE.Matrix4;

getExportRoots(view: PlanExportView): THREE.Object3D[];

toDrawing(view: PlanExportView): DrawingPrimitive[];

setOPConfig(config: OpenElementInput): void;

beginEdit(): void;

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

getOPConfig(): OpenElementConfig;

getControlSchema(): ControlSchema;

updateNodeProperty(nodeId: string, section: "profileView" | "modelView" | "definitions", property: string, value: number | string): void;

getEditAnchors(): EditAnchor[];

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

dispose(): void;

setConfig(options: Parameters<Polyline['setConfig']>[0]): void;

setOPGeometry(): void;

setOPMaterial(): void;

interface PortOwner {
  ogid: string;
  getPorts(): DistributionPort[];
}

interface OpenElementConfig extends OpenElementDefinition, HasPropertySets {
  ogid?: string;
}

type OpenElementInput = string | OpenElementDefinition | OpenElementOptions;

interface OpenElementDefinition {
  version: 1;
  id: string;
  labelName: string;
  type: ElementType;
  dimensions: OpenElementDimensions;
  placement?: Placement;
  metadata?: Record<string, string>;
  anchors?: OpenElementAnchors;
  ports?: PortDefinition[];
  definitions?: OpenElementDefinitions;
  profileView?: OpenElementProfileView;
  modelView?: OpenElementModelView;
}

interface AnchorDefinition {
  placement: Placement;
  metadata?: Record<string, string>;
}

interface ControlSchema {
  nodes: NodeControlDescriptor[];
}

interface DistributionPort {
  id: string;
  domain: PortDomain;
  systemType: string;
  flowDirection: PortFlowDirection;
  placement: Placement;
  profile: PortProfile;
  internal?: boolean;
  metadata?: Record<string, string>;
}

interface OpenElementOptions
  extends Partial<Omit<OpenElementConfig, 'version' | 'dimensions'>>, HasPropertySets {
  version?: 1;
  dimensions?: Partial<OpenElementDimensions>;
  source?: string | OpenElementDefinition;
}

interface OpenElementDimensions {
  width: number;
  depth: number;
  height: number;
}

type OpenElementAnchors = Record<string, AnchorDefinition>;

type PortDefinition = Omit<DistributionPort, 'internal'>;

type OpenElementDefinitions = Record<string, DefinitionNode>;

interface OpenElementProfileView {
  elements: ProfileViewElement[];
}

interface OpenElementModelView {
  elements: ModelViewElement[];
}

interface NodeControlDescriptor {
  nodeId: string;
  nodeKind: string;
  section: 'profileView' | 'modelView' | 'definitions';
  properties: PropertyDescriptor[];
}

type PortDomain = 'hvac' | 'piping' | 'electrical' | 'cableCarrier' | 'conduit';

type PortFlowDirection = 'source' | 'sink' | 'bidirectional';

type PortProfile =
  | {
      shape: 'round';
      diameter: number;
    }
  | {
      shape: 'rectangular';
      width: number;
      height: number;
    }
  | {
      shape: 'tray';
      width: number;
      height: number;
    }
  | {
      shape: 'electrical';
      poles: number;
      voltage?: number;
      amperage?: number;
    };

type DefinitionNode = ProfileNode | Curve3DNode | ModelNode | OperationNode;

type ProfileViewElement = ProfileNode | RefNode;

type ModelViewElement = ModelNode | RefNode;

interface PropertyDescriptor {
  key: string;
  type: ControlPropertyType;
  value: number | string;
  label?: string;
}

type ProfileNode = ProfilePolygonNode | ProfilePolylineNode | ProfileArcNode;

type Curve3DNode = Curve3DPolylineNode;

type ModelNode = ModelCuboidNode | ModelCylinderNode | ModelSweepNode;

type OperationNode = Offset2DOpNode | Boolean3DOpNode;

interface RefNode extends BaseElementNode {
  ref: string;
}

type ControlPropertyType = 'number' | 'color';

interface ProfilePolygonNode extends BaseElementNode {
  kind: 'polygon';
  vertices: Point2[];
}

interface ProfilePolylineNode extends BaseElementNode {
  kind: 'polyline';
  points: Point2[];
}

interface ProfileArcNode extends BaseElementNode {
  kind: 'arc';
  center: Point2;
  radius: number;
  startAngle: number;
  sweepAngle: number;
  deflection?: number;
}

interface Curve3DPolylineNode extends BaseElementNode {
  kind: 'polyline3d';
  points: Point3[];
}

interface ModelCuboidNode extends BaseElementNode {
  kind: 'cuboid';
  center: Point3;
  width: number;
  height: number;
  depth: number;
}

interface ModelCylinderNode extends BaseElementNode {
  kind: 'cylinder';
  center: Point3;
  radius: number;
  height: number;
  angle?: number;
}

type ModelSweepNode = ModelSweepDirectNode | ModelSweepRefNode;

interface Offset2DOpNode extends BaseElementNode {
  kind: 'offset2d';
  sourceRef: string;
  distance: number;
  acuteThresholdDegrees?: number;
  bevel?: boolean;
  output: 'polyline' | 'polygon';
}

interface Boolean3DOpNode extends BaseElementNode {
  kind: 'boolean3d';
  operation: 'subtract' | 'union' | 'intersect';
  baseRef: string;
  operandRefs: string[];
}

interface BaseElementNode {
  id?: string;
  color?: ColorValue;
  placement?: Placement;
}

type Point2 = [number, number];

type Point3 = [number, number, number];

interface ModelSweepDirectNode extends BaseElementNode {
  kind: 'sweep';
  path: Point3[];
  profile: Point3[];
  capStart?: boolean;
  capEnd?: boolean;
}

interface ModelSweepRefNode extends BaseElementNode {
  kind: 'sweep';
  pathRef: string;
  profileRef: string;
  capStart?: boolean;
  capEnd?: boolean;
}

type ColorValue = number | string;