Class DotloomEngine

capabilities

revision

isCrashed

• get isCrashed(): boolean

  Whether the engine crashed (create a new one and reload the document).

  Returns boolean

isDisposed

• get isDisposed(): boolean

  Whether dispose was called.

  Returns boolean

analyze

• analyze(): Promise<{ diagnostics: DiagnosticReport[]; status: SolveStatus }>

  Solve status and diagnostics of the whole document (nothing changes).

  Returns Promise<{ diagnostics: DiagnosticReport[]; status: SolveStatus }>

apply

• apply(tx: Transaction | Command[], opts?: CallOptions): Promise<CommitReport>

  Apply commands atomically. Rejects with solve diagnostics when hard rules fail.

  Parameters

  • tx: Transaction | Command[]
  • Optionalopts: CallOptions

  Returns Promise<CommitReport>

beginDrag

• beginDrag(spec: DragSpec): Promise<void>

  Parameters

  • spec: DragSpec

  Returns Promise<void>

copy

• copy(ids: number[]): Promise<Clipboard>

  Parameters

  • ids: number[]

  Returns Promise<Clipboard>

debugCrashForTesting

• debugCrashForTesting(): Promise<void>

  Test hook: crash the engine instance on purpose (verifies crash handling). Afterwards every call rejects with crashed; create a new engine.

  Returns Promise<void>

dispose

• dispose(): void

  Stop the engine and release its resources. Pending requests reject.

  Returns void

documentJson

• documentJson(): Promise<DocumentJson>

  The document as JSON (a derived copy; edit through transactions).

  Returns Promise<DocumentJson>

dragTo

• dragTo(p: Point): Promise<DragPreview | null>

  Move the drag. Resolves to null when a newer position superseded this one (only the newest position is solved).

  Parameters

  • p: Point

  Returns Promise<DragPreview | null>

endDrag

• endDrag(commit: boolean): Promise<CommitReport | null>

  Commit (one history entry) or cancel the drag.

  Parameters

  • commit: boolean

  Returns Promise<CommitReport | null>

entityInfo

• entityInfo(id: number): Promise<EntityInfo>

  Parameters

  • id: number

  Returns Promise<EntityInfo>

exportDxf

• exportDxf(): Promise<{ dxf: string; report: ConversionReport }>

  Returns Promise<{ dxf: string; report: ConversionReport }>

exportSvg

• exportSvg(
      opts?: { background?: string; foreground?: string; margin?: number },
  ): Promise<{ report: ConversionReport; svg: string }>

  Parameters

  • opts: { background?: string; foreground?: string; margin?: number } = {}

  Returns Promise<{ report: ConversionReport; svg: string }>

historyState

• historyState(): Promise<{ bytes: number; canRedo: boolean; canUndo: boolean }>

  Undo/redo availability.

  Returns Promise<{ bytes: number; canRedo: boolean; canUndo: boolean }>

hitTest

• hitTest(p: Point, radius: number): Promise<Hit[]>

  Entities under a model point within radius model units.

  Parameters

  • p: Point
  • radius: number

  Returns Promise<Hit[]>

importDxf

• importDxf(
      bytes: Uint8Array,
  ): Promise<{ commit: CommitReport; report: ConversionReport }>

  Import ASCII DXF as one undoable transaction.

  Parameters

  • bytes: Uint8Array

  Returns Promise<{ commit: CommitReport; report: ConversionReport }>

importSvg

• importSvg(
      text: string,
  ): Promise<{ commit: CommitReport; report: ConversionReport }>

  Import SVG as one undoable transaction.

  Parameters

  • text: string

  Returns Promise<{ commit: CommitReport; report: ConversionReport }>

load

• load(
      file: ArrayBuffer | Uint8Array<ArrayBufferLike> | Blob,
  ): Promise<LoadReport>

  Open a .dotl file. The caller's bytes are copied to the engine, never transferred: the array stays usable afterwards.

  Parameters

  • file: ArrayBuffer | Uint8Array<ArrayBufferLike> | Blob

  Returns Promise<LoadReport>

loadJson

• loadJson(doc: string | DocumentJson): Promise<number>

  Load a document from its JSON form.

  Parameters

  • doc: string | DocumentJson

  Returns Promise<number>

memory

• memory(): Promise<{ wasmBytes: number }>

  Engine WebAssembly memory in bytes. Linear memory never shrinks, so this is the high-water mark (e.g. the peak memory of opening a file).

  Returns Promise<{ wasmBytes: number }>

newDocument

• newDocument(): Promise<number>

  Start an empty document.

  Returns Promise<number>

on

• on<K extends keyof EventMap>(name: K, cb: Listener<K>): () => void

  Subscribe to an event; returns an unsubscribe function.

  Type Parameters

  • K extends keyof EventMap

  Parameters

  • name: K
  • cb: Listener<K>

  Returns () => void

pluginTypes

• pluginTypes(): Promise<
      {
          definition: EntityTypeDef;
          enabled: boolean;
          plugin: string;
          typeId: string;
      }[],
  >

  Registered plugin types.

  Returns Promise<
      {
          definition: EntityTypeDef;
          enabled: boolean;
          plugin: string;
          typeId: string;
      }[],
  >

redo

• redo(opts?: CallOptions): Promise<number>

  Redo the last undone commit.

  Parameters

  • Optionalopts: CallOptions

  Returns Promise<number>

registerTypes

• registerTypes(
      defs: EntityTypeDef | EntityTypeDef[],
      plugin?: string,
  ): Promise<string[]>

  Register plugin entity types (data definitions evaluated in Rust).

  Parameters

  • defs: EntityTypeDef | EntityTypeDef[]
  • plugin: string = 'plugin'

  Returns Promise<string[]>

requestFullScene

• requestFullScene(): Promise<void>

  Request a full scene (delivered through the scene event).

  Returns Promise<void>

reserveIds

• reserveIds(n: number): Promise<number[]>

  Reserve IDs for entities/constraints created in one transaction.

  Parameters

  • n: number

  Returns Promise<number[]>

save

• save(view?: unknown): Promise<Uint8Array<ArrayBufferLike>>

  Save as .dotl bytes; view is stored as view state (not geometry).

  Parameters

  • Optionalview: unknown

  Returns Promise<Uint8Array<ArrayBufferLike>>

selectInRect

• selectInRect(a: Point, b: Point, crossing: boolean): Promise<number[]>

  Window (inside) or crossing (touching) selection.

  Parameters

  • a: Point
  • b: Point
  • crossing: boolean

  Returns Promise<number[]>

selection

• selection(): Promise<number[]>

  Returns Promise<number[]>

setSelection

• setSelection(ids: number[]): Promise<void>

  Parameters

  • ids: number[]

  Returns Promise<void>

setTypeEnabled

• setTypeEnabled(typeId: string, enabled: boolean): Promise<void>

  Enable or disable a plugin type.

  Parameters

  • typeId: string
  • enabled: boolean

  Returns Promise<void>

snap

• snap(q: SnapQuery): Promise<Snap | null>

  Parameters

  • q: SnapQuery

  Returns Promise<Snap | null>

undo

• undo(opts?: CallOptions): Promise<number>

  Undo the last commit.

  Parameters

  • Optionalopts: CallOptions

  Returns Promise<number>

unregisterType

• unregisterType(typeId: string): Promise<void>

  Unregister a plugin type (its entities become read-only; data is kept).

  Parameters

  • typeId: string

  Returns Promise<void>

verify

• verify(): Promise<{ residual: number; rule: string; tolerance: number }[]>

  Hard rules violated by the stored values (independent check).

  Returns Promise<{ residual: number; rule: string; tolerance: number }[]>

Staticcreate

• create(options?: EngineOptions): Promise<DotloomEngine>

  Create and initialize an engine. In browsers the engine runs in a Web Worker.

  Parameters

  • options: EngineOptions = {}

  Returns Promise<DotloomEngine>