@inweb/viewer-visualize 25.3.13

package/src/Viewer/Draggers/OrbitAroundBuildingDragger.ts

@@ -0,0 +1,184 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+/* eslint-disable no-unused-vars */
+import { Viewer } from "../Viewer";
+import { Point2d } from "./Common/Geometry";
+import { ViewParams } from "./Common/OdaGeAction";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+export class OrbitAroundBuildingDragger extends OdBaseDragger {
+  protected maxPolarAngle: number;
+  protected minPolarAngle: number;
+  protected m_viewCenter: any;
+  protected m_startPoint: Point2d;
+  protected startCameraParams: ViewParams;
+  protected m_delta: number;
+
+  constructor(viewer: Viewer) {
+    super(viewer);
+    this.autoSelect = true;
+    this.press = false;
+    this.maxPolarAngle = Math.PI / 2;
+    this.minPolarAngle = 0; // radians
+  }
+
+  override start(x: number, y: number): void {
+    this.press = true;
+
+    this.m_viewCenter = this.getCenter();
+    this.m_startPoint = { x, y };
+
+    const view = this.getViewer().activeView;
+
+    this.startCameraParams = this.getViewParams();
+
+    const corners = view.vportRect;
+
+    this.m_delta = Math.max(corners[1] - corners[0], corners[2] - corners[3]);
+
+    this.beginInteractivity();
+  }
+
+  setDefaultViewParams(): void {
+    this.setViewParams(this.startCameraParams);
+  }
+
+  override drag(x: number, y: number, dltX: number, dltY: number): void {
+    if (this.press) {
+      let dX = x - this.m_startPoint.x;
+      let dY = y - this.m_startPoint.y;
+
+      dX *= Math.PI / this.m_delta;
+      dY *= Math.PI / this.m_delta;
+
+      this.setDefaultViewParams();
+
+      const { Vector3d, Matrix3d } = this.m_module;
+
+      const target = Vector3d.createFromArray(this.startCameraParams.target);
+      const offset = Vector3d.createFromArray(this.startCameraParams.position).sub(target);
+      const dir = offset.normalize();
+
+      const zMatrix = new Matrix3d();
+      zMatrix.setToIdentity();
+      const xMatrix = new Matrix3d();
+      xMatrix.setToIdentity();
+
+      // ---- restore start rotation ----
+
+      const yAxis = Vector3d.createFromArray([dir.x, dir.y, dir.z]);
+      const zAxis = Vector3d.createFromArray(this.startCameraParams.upVector);
+      const xAxis = yAxis.crossProduct(zAxis);
+
+      // ----------- zAxis rotation restore -----------
+      let xyDir = Vector3d.createFromArray([yAxis.x, yAxis.y, 0]);
+
+      if (xyDir.length() <= 0.00001) {
+        xyDir.set(-xAxis.y, xAxis.x, 0);
+      } else {
+        xyDir = xyDir.normalize();
+      }
+      const xyAngle =
+        Math.sign(xyDir.dotProduct(Vector3d.createFromArray([-1, 0, 0]))) *
+        xyDir.angleTo(Vector3d.createFromArray([0, 1, 0]));
+      dX -= xyAngle;
+      // ----------- zAxis rotation restore -----------
+
+      // ----------- xAxis rotation restore -----------
+      let yzDir = Vector3d.createFromArray([dir.x, dir.y, 0]);
+      let yzAngle = 0;
+      if (yzDir.length() <= 0.00001) {
+        yzAngle = (-dir.z * Math.PI) / 2;
+      } else {
+        yzDir = yzDir.normalize();
+        yzAngle = -yzDir.angleTo(dir);
+      }
+      dY -= yzAngle;
+      // ----------- xAxis rotation restore -----------
+
+      // ---- restore start rotation ----
+
+      zMatrix.setToRotation(-dX, [0, 0, 1], [0, 0, 0]);
+
+      const xAngle = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, dY));
+      xMatrix.setToRotation(xAngle, [1, 0, 0], [0, 0, 0]);
+
+      const endMatrix = zMatrix.postMultBy(xMatrix);
+
+      let pos = Vector3d.createFromArray([0, 1, 0]).transformBy(endMatrix);
+      const up = Vector3d.createFromArray([0, 0, 1]).transformBy(endMatrix);
+
+      pos.setLength(offset.length());
+      pos = target.add(pos);
+
+      const current = this.getViewParams();
+
+      current.position = pos.toArray();
+      current.upVector = up.toArray();
+
+      this.setViewParams(current);
+    }
+  }
+
+  override end(): void {
+    this.press = false;
+    this.endInteractivity();
+  }
+
+  getCenter(): any {
+    const viewer = this.getViewer();
+
+    let ext = viewer.getActiveExtents();
+
+    const pSet = viewer.getSelected();
+    if (!pSet.isNull() && pSet.numItems() !== 0) {
+      const itr = pSet.getIterator();
+      const entId = itr.getEntity();
+
+      if (entId.getType() === 1) {
+        const obj = entId.openObject();
+
+        ext.delete();
+        ext = obj.getExtents();
+
+        obj.delete();
+      } else if (entId.getType() === 2) {
+        const obj = entId.openObjectAsInsert();
+        const extTuple = obj.getExtents();
+
+        ext.delete();
+        ext = extTuple.ext;
+
+        extTuple.delete();
+        obj.delete();
+      }
+
+      itr.delete();
+    }
+
+    const center = ext.center();
+
+    ext.delete();
+    return center;
+  }
+}

package/src/Viewer/Loaders/BaseLoader.ts

@@ -0,0 +1,40 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { Model } from "@inweb/client";
+import { OptionsData } from "@inweb/viewer-core";
+import { Viewer } from "../Viewer";
+
+export class BaseLoader {
+  protected viewer: Viewer;
+  protected model: Model;
+  protected options: OptionsData;
+
+  constructor(viewer: Viewer, model: Model, options: OptionsData) {
+    this.viewer = viewer;
+    this.model = model;
+    this.options = options;
+  }
+
+  async load(): Promise<void> {}
+}

package/src/Viewer/Loaders/LoaderFactory.ts

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { Model } from "@inweb/client";
+import { OptionsData } from "@inweb/viewer-core";
+
+import { TCSLoader } from "./TCSLoader";
+import { VsfXStreamingLoader } from "./VsfXStreamingLoader";
+import { VsfXPartialLoader } from "./VsfXPartialLoader";
+import { Viewer } from "../Viewer";
+import { VsfXLoader } from "./VsfXLoader";
+
+export class LoaderFactory {
+  create(viewer: Viewer, model: Model, options: OptionsData) {
+    const geometryType = model.database.split(".").pop();
+
+    if (model.geometry.length === 0 && geometryType === "vsfx") {
+      if (!options.enableStreamingMode) return new VsfXLoader(viewer, model, options);
+      else if (options.enablePartialMode) return new VsfXPartialLoader(viewer, model, options);
+      else return new VsfXStreamingLoader(viewer, model, options);
+    }
+
+    if (geometryType === "data") {
+      return new TCSLoader(viewer, model, options);
+    }
+    throw new Error(`Unknown geometry type: ${geometryType}`);
+  }
+}

package/src/Viewer/Loaders/TCSLoader.ts

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { BaseLoader } from "./BaseLoader";
+
+export class TCSLoader extends BaseLoader {
+  override async load(): Promise<void> {
+    if (!this.viewer.visualizeJs) return;
+
+    const visLib = this.viewer.visLib();
+    const visViewer = visLib.getViewer();
+    const abortController = new AbortController();
+
+    const listFileForDownload = [this.model.database, ...this.model.geometry];
+    const chunksProgress = listFileForDownload.map(() => 0);
+
+    const calcProgress = (index, progress) => {
+      chunksProgress[index] = progress;
+      const fileProgress = chunksProgress.reduce((acc, progress) => (acc += progress)) / (chunksProgress.length || 1);
+      this.viewer.emitEvent({ type: "geometryprogress", data: fileProgress, model: this.model });
+    };
+
+    this.viewer._abortController = abortController;
+
+    try {
+      this.viewer.emitEvent({ type: "geometrystart", model: this.model });
+
+      for (let i = 0; i < listFileForDownload.length; i++) {
+        const chunk = listFileForDownload[i];
+
+        const progressCb = (progress) => calcProgress(i, progress);
+        const arrayBuffer = await this.model.downloadResource(chunk, progressCb, abortController.signal);
+
+        if (abortController.signal.aborted) {
+          await Promise.reject(new Error(`Open model aborted ${this.model.name}`));
+        }
+
+        visViewer.parseStream(new Uint8Array(arrayBuffer));
+        this.viewer.update();
+
+        const data = new Uint8Array(arrayBuffer);
+
+        if (i === 0) {
+          this.viewer.update(true);
+
+          this.viewer.syncOpenCloudVisualStyle(false);
+          this.viewer.syncOptions();
+          this.viewer.resize();
+
+          this.viewer.emitEvent({ type: "databasechunk", data, model: this.model });
+        } else {
+          this.viewer.emitEvent({ type: "geometrychunk", data, model: this.model });
+        }
+      }
+
+      this.viewer.emitEvent({ type: "geometryend", model: this.model });
+    } catch (error) {
+      this.viewer.emitEvent({ type: "geometryerror", data: error, model: this.model });
+      throw error;
+    }
+  }
+}

package/src/Viewer/Loaders/UpdaterController.ts

@@ -0,0 +1,36 @@
+import { Viewer } from "../Viewer";
+
+const DELAY_TIME_MULTIPLEXER = 2.0;
+const START_UPDATE_TIME = 1000;
+
+export enum UpdateType {
+  kDelay,
+  kNormal,
+  kForce,
+}
+
+export class UpdaterController {
+  private lastUpdate: number;
+  private viewer: Viewer;
+  public delayUpdateTime: number;
+
+  constructor() {
+    this.delayUpdateTime = START_UPDATE_TIME;
+  }
+
+  initialize(viewer: Viewer) {
+    this.viewer = viewer;
+    this.lastUpdate = performance.now();
+  }
+
+  update(type: UpdateType) {
+    const isNeedUpdate = type !== UpdateType.kDelay || performance.now() - this.lastUpdate >= this.delayUpdateTime;
+    const isForce = type === UpdateType.kForce;
+
+    if (isNeedUpdate) {
+      this.viewer.update(isForce);
+      this.lastUpdate = performance.now();
+      this.delayUpdateTime *= DELAY_TIME_MULTIPLEXER;
+    }
+  }
+}

package/src/Viewer/Loaders/VsfXLoader.ts

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { BaseLoader } from "./BaseLoader";
+
+export class VsfXLoader extends BaseLoader {
+  override async load(): Promise<void> {
+    if (!this.viewer.visualizeJs) return;
+
+    const visLib = this.viewer.visLib();
+    const visViewer = visLib.getViewer();
+    const abortController = new AbortController();
+
+    this.viewer._abortController = abortController;
+
+    console.time("File load time");
+    try {
+      this.viewer.emitEvent({ type: "geometrystart", model: this.model });
+
+      const progressCb = (progress) =>
+        this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
+      const arrayBuffer = await this.model.downloadResource(this.model.database, progressCb, abortController.signal);
+
+      if (abortController.signal.aborted) {
+        await Promise.reject(new Error(`Open model aborted ${this.model.name}`));
+      }
+
+      if (this.viewer.visualizeJs) {
+        visViewer.parseVsfx(new Uint8Array(arrayBuffer));
+        this.viewer.update(true);
+
+        this.viewer.syncOpenCloudVisualStyle(false);
+        this.viewer.syncOptions();
+        this.viewer.resize();
+      }
+
+      console.timeEnd("File load time");
+
+      this.viewer.emitEvent({ type: "geometryend", model: this.model });
+    } catch (error) {
+      this.viewer.emitEvent({ type: "geometryerror", data: error, model: this.model });
+      throw error;
+    }
+  }
+}

package/src/Viewer/Loaders/VsfXPartialLoader.ts

@@ -0,0 +1,208 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { BaseLoader } from "./BaseLoader";
+import { UpdaterController, UpdateType } from "./UpdaterController";
+
+export class VsfXPartialLoader extends BaseLoader {
+  override async load(): Promise<void> {
+    if (!this.viewer.visualizeJs) return;
+
+    const visLib = this.viewer.visLib();
+    const visViewer = visLib.getViewer();
+    const abortController = new AbortController();
+    const abortControllerForRequestMap = new Map();
+    let servicePartAborted = false;
+
+    const pendingRequestsMap = new Map();
+    const PENDING_REQUESTS_SIZE = 50;
+    const PENDING_REQUESTS_TIMEOUT = 250;
+    let pendingRequestsTimerId = 0;
+    const pendingRequestsAbortHandler = () => clearTimeout(pendingRequestsTimerId);
+
+    const pendingRequestsAbortController = new AbortController();
+    abortControllerForRequestMap.set(0, pendingRequestsAbortController);
+
+    const updaterController = new UpdaterController();
+    updaterController.initialize(this.viewer);
+
+    this.viewer._abortController = abortController;
+    this.viewer._abortControllerForRequestMap = abortControllerForRequestMap;
+
+    visViewer.memoryLimit = this.options.memoryLimit;
+
+    const requestLoadHandler = (progress, data, requestId) => {
+      if (!this.viewer.visualizeJs) return;
+
+      const state = visViewer.parseVsfxInPartialMode(requestId, data);
+      updaterController.update(UpdateType.kDelay);
+
+      this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
+
+      if (state) {
+        updaterController.update(UpdateType.kForce);
+
+        this.viewer.syncOpenCloudVisualStyle(false);
+        this.viewer.syncOptions();
+        this.viewer.resize();
+
+        this.viewer.emitEvent({ type: "databasechunk", data, model: this.model });
+      } else {
+        this.viewer.emitEvent({ type: "geometrychunk", data, model: this.model });
+      }
+    };
+
+    const downloadPartOfFile = async (requestId, records, dataId, isMultipleParts = false) => {
+      const abortCtrl = new AbortController();
+      abortControllerForRequestMap.set(requestId, abortCtrl);
+      try {
+        await this.model.downloadFileRange(requestId, records, dataId, requestLoadHandler, abortCtrl.signal);
+      } catch (error) {
+        this.viewer.emitEvent({ type: "geometryerror", data: error, model: this.model });
+      } finally {
+        const requests = isMultipleParts ? [...new Set(records.map((item) => item.reqId))] : [requestId];
+        requests.forEach((requestId) => visViewer.onRequestResponseComplete(requestId));
+        abortControllerForRequestMap.delete(requestId);
+        updaterController.update(UpdateType.kNormal);
+      }
+    };
+
+    const recordsToArray = (requestId, records) => {
+      const res = [];
+      for (let i = 0; i < records.size(); i++) {
+        const record = records.get(i);
+        res.push({
+          reqId: requestId,
+          begin: record.begin,
+          end: record.end,
+          size: parseInt(record.end, 10) - parseInt(record.begin, 10),
+        });
+        record.delete();
+      }
+      return res;
+    };
+
+    const objectHandler = {
+      onServicePartReceived: (bHasIndex) => {
+        if (bHasIndex) {
+          servicePartAborted = true;
+          abortController.abort();
+        }
+      },
+
+      onRequest: (requestId, records) => {
+        downloadPartOfFile(requestId, records, this.model.database);
+      },
+
+      onFullLoaded: () => {
+        updaterController.update(UpdateType.kNormal);
+        console.timeEnd("File load time");
+      },
+
+      onRequestResponseParsed: (requestId) => {
+        abortControllerForRequestMap.delete(requestId);
+        updaterController.update(UpdateType.kNormal);
+      },
+
+      onRequestAborted: (requestId) => {
+        const abortCtrl = abortControllerForRequestMap.get(requestId);
+        if (abortCtrl) abortCtrl.abort();
+      },
+
+      onRequestResourceFile: async (requestId, _, records) => {
+        const dataId = `${this.model.fileId}${this.model.file.type}`;
+
+        let pendingRequests = [];
+        let recNumber = 0;
+        const pendingRequestsRecord = pendingRequestsMap.get(dataId);
+        if (pendingRequestsRecord) {
+          pendingRequests = pendingRequestsRecord.array;
+          recNumber = pendingRequestsRecord.number;
+        }
+
+        // first several records of each file are processed without grouping (they usually require to be processed sequentially)
+        if (recNumber < 6) {
+          pendingRequestsMap.set(dataId, { array: pendingRequests, number: recNumber + 1 });
+          await downloadPartOfFile(requestId, records, dataId);
+          return;
+        }
+
+        // group requests to each file to launch a combined server request
+        if (pendingRequests.length >= PENDING_REQUESTS_SIZE) {
+          if (pendingRequestsTimerId) {
+            window.clearTimeout(pendingRequestsTimerId);
+            pendingRequestsTimerId = 0;
+          }
+
+          downloadPartOfFile(requestId, pendingRequests, dataId, true);
+          pendingRequests = [...recordsToArray(requestId, records)];
+        } else {
+          pendingRequests = [...pendingRequests, ...recordsToArray(requestId, records)];
+        }
+
+        pendingRequestsMap.set(dataId, { array: pendingRequests, number: recNumber + 1 });
+
+        // set timeout to wait for the new requests, after that process the remaining requests
+        if (pendingRequestsTimerId === 0) {
+          pendingRequestsTimerId = window.setTimeout(() => {
+            pendingRequestsAbortController.signal.removeEventListener("abort", pendingRequestsAbortHandler);
+            pendingRequestsTimerId = 0;
+
+            pendingRequestsMap.forEach((requestsRecord, keyFileName) => {
+              const array = requestsRecord.array;
+              if (array.length > 0) {
+                downloadPartOfFile(requestId, array, keyFileName, true);
+                pendingRequestsMap.set(keyFileName, { array: [], number: requestsRecord.number + 1 });
+              }
+            });
+          }, PENDING_REQUESTS_TIMEOUT);
+
+          pendingRequestsAbortController.signal.addEventListener("abort", pendingRequestsAbortHandler, { once: true });
+        }
+      },
+    };
+
+    visViewer.attachPartialResolver(objectHandler);
+
+    console.time("File load time");
+    try {
+      this.viewer.emitEvent({ type: "geometrystart", model: this.model });
+
+      await this.model
+        .downloadFileRange(0, null, this.model.database, requestLoadHandler, abortController.signal)
+        .catch((error) => {
+          if (!servicePartAborted) throw error;
+        });
+
+      this.viewer.emitEvent({ type: "geometryend", model: this.model });
+    } catch (error) {
+      if (pendingRequestsTimerId) {
+        window.clearTimeout(pendingRequestsTimerId);
+        pendingRequestsTimerId = 0;
+      }
+
+      this.viewer.emitEvent({ type: "geometryerror", data: error, model: this.model });
+      throw error;
+    }
+  }
+}