OPBaseProject

import { OPBaseProject, loadOPBaseAssetSources } from '@opengeometry/floorkit';

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

async function example(wasmURL: string): Promise<void> {
  await new Floorkit().setupOpenGeometry(wasmURL);
  const project = new OPBaseProject({
    id: 'equipment-layout',
    name: 'Equipment layout',
    assets: {
      equipment: {
        id: 'equipment',
        kind: 'embedded-op',
        definition: {
          version: 1,
          id: 'equipment',
          labelName: 'Equipment',
          type: ElementType.FURNITURE,
          dimensions: { width: 1, depth: 0.6, height: 0.9 },
        },
      },
    },
    nodes: {
      first: {
        id: 'first',
        assetRef: 'equipment',
        placement: { position: [1, 0, 2], rotation: [0, 0, 0], scale: [1, 1, 1] },
      },
    },
    roots: ['first'],
  });
  try {
    project.setNodePlacement('first', {
      position: [2, 0, 3],
      rotation: [0, 0, 0],
      scale: [1, 1, 1],
    });
    console.log(project.getNode('first')?.worldPlacement);
    console.log(project.getOPBaseBuffer());
  } finally {
    project.dispose();
  }
}

constructor(config?: OPBaseInput);

static parseBuffer(buffer: string): OPBaseDocument;

static normalizeDocument(document: unknown): OPBaseDocument;

getOPBaseBuffer(): string;

getOPBaseConfig(): OPBaseConfig;

setOPBaseConfig(config: OPBaseInput): void;

setNodePlacement(nodeId: string, placement: Placement): void;

getAsset(id: string): OPBaseResolvedAsset | undefined;

getNode(id: string): OPBaseResolvedNode | undefined;

getRelation(id: string): OPBaseRelation | undefined;

getExportElements(): OpenElement[];

resolveProject(): OPBaseResolvedDocument;

generateExportDocument(): OPBaseResolvedDocument;

dispose(): void;

function loadOPBaseAssetSources(
  document: OPBaseDocument,
  assetBaseUrl?: string,
): Promise<Record<string, string>>;

interface OPBaseConfig extends OPBaseDocument {
  ogid?: string;
}

type OPBaseInput = string | OPBaseDocument | OPBaseOptions;

interface OPBaseDocument {
  version: 1;
  id: string;
  name: string;
  units: 'meters';
  assets: Record<string, OPBaseAsset>;
  nodes: Record<string, OPBaseNode>;
  roots: string[];
  relations?: Record<string, OPBaseRelation>;
  metadata?: Record<string, string>;
}

interface OPBaseResolvedAsset {
  id: string;
  kind: OPBaseAsset['kind'];
  definition: OpenElementDefinition;
  sourceUri?: string;
}

interface OPBaseResolvedNode {
  id: string;
  assetRef: string;
  parentId?: string;
  visible: boolean;
  locked: boolean;
  localPlacement: Placement;
  worldPlacement: Placement;
  childIds: string[];
  relationIds: string[];
  container: THREE.Group;
  element: OpenElement;
  overrides?: OPBaseNodeOverrides;
}

interface OPBaseRelation {
  id: string;
  kind: 'attachedTo' | 'hostedBy' | 'insertedInto' | 'dependsOn' | 'groupMember';
  from: string;
  to: string;
  attachment?: AttachmentSpec;
  metadata?: Record<string, string>;
}

interface OPBaseResolvedDocument {
  id: string;
  name: string;
  units: 'meters';
  metadata?: Record<string, string>;
  assets: Record<string, OPBaseResolvedAsset>;
  nodes: Record<string, OPBaseResolvedNode>;
  roots: string[];
  relations: Record<string, OPBaseRelation>;
  elements: OpenElement[];
}

interface OPBaseOptions extends Partial<
  Omit<OPBaseConfig, 'version' | 'assets' | 'nodes' | 'roots'>
> {
  version?: 1;
  assets?: Record<string, OPBaseAsset>;
  nodes?: Record<string, OPBaseNode>;
  roots?: string[];
  relations?: Record<string, OPBaseRelation>;
  source?: string | OPBaseDocument;
  assetBaseUrl?: string;
  assetSources?: Record<string, string | OpenElementDefinition>;
}

type OPBaseAsset = OPBaseExternalAsset | OPBaseEmbeddedAsset;

interface OPBaseNode {
  id: string;
  assetRef: string;
  parentId?: string;
  placement: Placement;
  visible?: boolean;
  locked?: boolean;
  overrides?: OPBaseNodeOverrides;
}

interface OPBaseNodeOverrides {
  labelName?: string;
  metadata?: Record<string, string>;
  dimensions?: OpenElementDimensions;
}

interface AttachmentSpec {
  hostAnchorId?: string;
  childAnchorId?: string;
  offset?: Placement;
  alignment?: 'match' | 'flipX' | 'flipY' | 'flipZ';
  face?: string;
  slot?: string;
}

interface OPBaseExternalAsset {
  id: string;
  kind: 'external-op';
  uri: string;
}

interface OPBaseEmbeddedAsset {
  id: string;
  kind: 'embedded-op';
  definition: OpenElementDefinition;
}