@inweb/client 25.3.18 → 25.3.19

package/lib/Api/Assembly.d.ts

@@ -240,11 +240,11 @@ export declare class Assembly {
      *   ="_blank">AbortSignal</a> object instance. Allows to communicate with a fetch request
      *   and abort it if desired.
      */
-    downloadResourceRange(dataId: string, ranges: Array<{
+    downloadResourceRange(dataId: string, requestId: number, ranges: Array<{
         begin: number;
         end: number;
         requestId: number;
-    }>, requestId: number, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
+    }>, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
     /**
      * Deprecated since `25.3`. Use {@link Assembly.downloadResource()} instead.
      */

package/lib/Api/File.d.ts

@@ -363,11 +363,11 @@ export declare class File {
      *   ="_blank">AbortSignal</a> object instance. Allows to communicate with a fetch request
      *   and abort it if desired.
      */
-    downloadResourceRange(dataId: string, ranges: Array<{
+    downloadResourceRange(dataId: string, requestId: number, ranges: Array<{
         begin: number;
         end: number;
         requestId: number;
-    }>, requestId: number, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
+    }>, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
     /**
      * Deprecated since `25.3`. Use {@link File.downloadResource()} instead.
      */

package/lib/Api/HttpClient.d.ts

@@ -10,7 +10,7 @@ export declare class HttpClient implements IHttpClient {
     delete(relativePath: string): Promise<Response>;
     uploadFile(relativePath: string, file: File, onProgress?: (progress: number) => void): Promise<XMLHttpRequest>;
     downloadFile(relativePath: string, onProgress?: (progress: number, chunk: Uint8Array) => void, signal?: AbortSignal): Promise<Response>;
-    downloadFileRange(relativePath: string, ranges: Array<{
+    downloadFileRange(relativePath: string, requestId: number, ranges: Array<{
         begin: number;
         end: number;
         requestId: number;

package/lib/Api/IHttpClient.d.ts

@@ -8,7 +8,7 @@ export interface IHttpClient {
     delete(relativePath: string): Promise<Response>;
     uploadFile(relativePath: string, file: globalThis.File, onProgress?: (progress: number) => void): Promise<XMLHttpRequest>;
     downloadFile(relativePath: string, onProgress?: (progress: number, chunk: Uint8Array) => void, signal?: AbortSignal): Promise<Response>;
-    downloadFileRange(relativePath: string, ranges: Array<{
+    downloadFileRange(relativePath: string, requestId: number, ranges: Array<{
         begin: number;
         end: number;
         requestId: number;

package/lib/Api/Model.d.ts

@@ -169,11 +169,11 @@ export declare class Model {
      *   ="_blank">AbortSignal</a> object instance. Allows to communicate with a fetch request
      *   and abort it if desired.
      */
-    downloadResourceRange(dataId: string, ranges: Array<{
+    downloadResourceRange(dataId: string, requestId: number, ranges: Array<{
         begin: number;
         end: number;
         requestId: number;
-    }>, requestId: number, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
+    }>, onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void, signal?: AbortSignal): Promise<ArrayBuffer>;
     /**
      * Deprecated since `25.3`. Use {@link Model.downloadResource()} instead.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inweb/client",
-  "version": "25.3.18",
+  "version": "25.3.19",
   "description": "JavaScript REST API client for the Open Cloud Server",
   "homepage": "https://cloud.opendesign.com/docs/index.html",
   "license": "SEE LICENSE IN LICENSE",
@@ -27,6 +27,6 @@
     "ts-docs": "typedoc"
   },
   "dependencies": {
-    "@inweb/eventemitter2": "^25.3.13"
+    "@inweb/eventemitter2": "^25.3.18"
   }
 }

package/src/Api/Assembly.ts

@@ -441,14 +441,14 @@ export class Assembly {
    */
   downloadResourceRange(
     dataId: string,
-    ranges: Array<{ begin: number; end: number; requestId: number }>,
     requestId: number,
+    ranges: Array<{ begin: number; end: number; requestId: number }>,
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal
   ): Promise<ArrayBuffer> {
     const relativePath = this.appendVersionParam(`/downloads/${dataId}?requestId=${requestId}`);
     return this.httpClient
-      .downloadFileRange(`${this.path}${relativePath}`, ranges, onProgress, signal)
+      .downloadFileRange(`${this.path}${relativePath}`, requestId, ranges, onProgress, signal)
       .then((response) => response.arrayBuffer());
   }
 
@@ -476,7 +476,7 @@ export class Assembly {
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal
   ): Promise<void> {
-    await this.downloadResourceRange(dataId, records, requestId, onProgress, signal);
+    await this.downloadResourceRange(dataId, requestId, records, onProgress, signal);
   }
 
   // Reserved for future use

package/src/Api/File.ts

@@ -587,14 +587,14 @@ export class File {
    */
   downloadResourceRange(
     dataId: string,
-    ranges: Array<{ begin: number; end: number; requestId: number }>,
     requestId: number,
+    ranges: Array<{ begin: number; end: number; requestId: number }>,
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal
   ): Promise<ArrayBuffer> {
     const relativePath = this.appendVersionParam(`/downloads/${dataId}?requestId=${requestId}`);
     return this.httpClient
-      .downloadFileRange(`${this.path}${relativePath}`, ranges, onProgress, signal)
+      .downloadFileRange(`${this.path}${relativePath}`, requestId, ranges, onProgress, signal)
       .then((response) => response.arrayBuffer());
   }
 
@@ -622,7 +622,7 @@ export class File {
     onProgress?: (progress: number, downloaded: Uint8Array, requestId: number) => void,
     signal?: AbortSignal
   ): Promise<void> {
-    await this.downloadResourceRange(dataId, records, requestId, onProgress, signal);
+    await this.downloadResourceRange(dataId, requestId, records, onProgress, signal);
   }
 
   /**

package/src/Api/HttpClient.ts

@@ -111,6 +111,7 @@ export class HttpClient implements IHttpClient {
 
   async downloadFileRange(
     relativePath: string,
+    requestId: number,
     ranges: Array<{ begin: number; end: number; requestId: number }>,
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal

package/src/Api/IHttpClient.ts

@@ -48,6 +48,7 @@ export interface IHttpClient {
 
   downloadFileRange(
     relativePath: string,
+    requestId: number,
     ranges: Array<{ begin: number; end: number; requestId: number }>,
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal

package/src/Api/Model.ts

@@ -279,12 +279,12 @@ export class Model {
    */
   downloadResourceRange(
     dataId: string,
-    ranges: Array<{ begin: number; end: number; requestId: number }>,
     requestId: number,
+    ranges: Array<{ begin: number; end: number; requestId: number }>,
     onProgress?: (progress: number, chunk: Uint8Array, requestId: number) => void,
     signal?: AbortSignal
   ): Promise<ArrayBuffer> {
-    return this._file.downloadResourceRange(dataId, ranges, requestId, onProgress, signal);
+    return this._file.downloadResourceRange(dataId, requestId, ranges, onProgress, signal);
   }
 
   /**
@@ -328,7 +328,7 @@ export class Model {
       }
     }
 
-    await this.downloadResourceRange(dataId, ranges, requestId, onProgress, signal);
+    await this.downloadResourceRange(dataId, requestId, ranges, onProgress, signal);
   }
 
   /**

package/lib/ConvetMath.d.ts

@@ -1,28 +0,0 @@
-/**
- * Convert world coordinates to screen normalized (-1, 1)
- *
- * @param viewMatrix Camera world matrix
- * @param projectionMatrix Camera projection matrix
- * @param worldPoint World point
- */
-export declare function worldToScreenNormalized(viewMatrix: Array<number>, projectionMatrix: Array<number>, worldPoint: [x: number, y: number, z: number]): [x: number, y: number, z: number];
-export declare function multiplyMatrices(a: Array<number>, b: Array<number>): Array<number>;
-/**
- * @param matrix
- * @returns Matrix
- */
-export declare function invertMatrix(matrix: Array<number>): Array<number>;
-/**
- * Convert world coordinates to screen (screenWidth, screenHeight)
- *
- * @param viewMatrix Camera world matrix
- * @param projectionMatrix Camera projection matrix
- * @param worldPoint World point
- * @param screenWidth Screen width
- * @param screenHeight Screen height
- */
-export declare function worldToScreen(viewMatrix: Array<number>, projectionMatrix: Array<number>, worldPoint: [x: number, y: number, z: number], screenWidth: number, screenHeight: number): number[];
-export declare function createOrthoProjectionMatrix(camera: any, width: any, height: any): number[];
-export declare function createViewMatrix(camera: any): any[];
-export declare function bcfWorldToScreenFromCamera(camera: any, canvas: HTMLCanvasElement, point: [x: number, y: number, z: number]): number[];
-export declare function matrixLookAt(matrix: any, eye: any, target: any, up: any): any;

package/src/ConvetMath.ts

@@ -1,372 +0,0 @@
-/**
- * Convert world coordinates to screen normalized (-1, 1)
- *
- * @param viewMatrix Camera world matrix
- * @param projectionMatrix Camera projection matrix
- * @param worldPoint World point
- */
-export function worldToScreenNormalized(
-  viewMatrix: Array<number>,
-  projectionMatrix: Array<number>,
-  worldPoint: [x: number, y: number, z: number]
-): [x: number, y: number, z: number] {
-  function applyMatrixToPoint3(matrix, point: [x: number, y: number, z: number]): [x: number, y: number, z: number] {
-    const [x, y, z] = point;
-    const e = matrix;
-    const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
-
-    return [
-      (e[0] * x + e[4] * y + e[8] * z + e[12]) * w,
-      (e[1] * x + e[5] * y + e[9] * z + e[13]) * w,
-      (e[2] * x + e[6] * y + e[10] * z + e[14]) * w,
-    ];
-  }
-
-  const [x, y, z] = applyMatrixToPoint3(projectionMatrix, applyMatrixToPoint3(invertMatrix(viewMatrix), worldPoint));
-
-  return [x, y, z];
-}
-
-export function multiplyMatrices(a: Array<number>, b: Array<number>): Array<number> {
-  const ae = a;
-  const be = b;
-  const te = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-
-  const a11 = ae[0],
-    a12 = ae[4],
-    a13 = ae[8],
-    a14 = ae[12];
-  const a21 = ae[1],
-    a22 = ae[5],
-    a23 = ae[9],
-    a24 = ae[13];
-  const a31 = ae[2],
-    a32 = ae[6],
-    a33 = ae[10],
-    a34 = ae[14];
-  const a41 = ae[3],
-    a42 = ae[7],
-    a43 = ae[11],
-    a44 = ae[15];
-
-  const b11 = be[0],
-    b12 = be[4],
-    b13 = be[8],
-    b14 = be[12];
-  const b21 = be[1],
-    b22 = be[5],
-    b23 = be[9],
-    b24 = be[13];
-  const b31 = be[2],
-    b32 = be[6],
-    b33 = be[10],
-    b34 = be[14];
-  const b41 = be[3],
-    b42 = be[7],
-    b43 = be[11],
-    b44 = be[15];
-
-  te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
-  te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
-  te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
-  te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
-
-  te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
-  te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
-  te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
-  te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
-
-  te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
-  te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
-  te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
-  te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
-
-  te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
-  te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
-  te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
-  te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
-
-  return te;
-}
-
-/**
- * @param matrix
- * @returns Matrix
- */
-export function invertMatrix(matrix: Array<number>): Array<number> {
-  const te = matrix,
-    n11 = te[0],
-    n21 = te[1],
-    n31 = te[2],
-    n41 = te[3],
-    n12 = te[4],
-    n22 = te[5],
-    n32 = te[6],
-    n42 = te[7],
-    n13 = te[8],
-    n23 = te[9],
-    n33 = te[10],
-    n43 = te[11],
-    n14 = te[12],
-    n24 = te[13],
-    n34 = te[14],
-    n44 = te[15],
-    t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
-    t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
-    t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
-    t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
-
-  const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
-
-  if (det === 0) return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-  const detInv = 1 / det;
-
-  return [
-    t11 * detInv,
-    (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) *
-      detInv,
-    (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) *
-      detInv,
-    (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) *
-      detInv,
-
-    t12 * detInv,
-    (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) *
-      detInv,
-    (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) *
-      detInv,
-    (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) *
-      detInv,
-
-    t13 * detInv,
-    (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) *
-      detInv,
-    (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) *
-      detInv,
-    (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) *
-      detInv,
-
-    t14 * detInv,
-    (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) *
-      detInv,
-    (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) *
-      detInv,
-    (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) *
-      detInv,
-  ];
-}
-
-/**
- * Convert world coordinates to screen (screenWidth, screenHeight)
- *
- * @param viewMatrix Camera world matrix
- * @param projectionMatrix Camera projection matrix
- * @param worldPoint World point
- * @param screenWidth Screen width
- * @param screenHeight Screen height
- */
-export function worldToScreen(
-  viewMatrix: Array<number>,
-  projectionMatrix: Array<number>,
-  worldPoint: [x: number, y: number, z: number],
-  screenWidth: number,
-  screenHeight: number
-) {
-  const widthHalf = screenWidth / 2;
-  const heightHalf = screenHeight / 2;
-
-  const [x, y] = worldToScreenNormalized(viewMatrix, projectionMatrix, worldPoint);
-  const p = [x * widthHalf + widthHalf, -(y * heightHalf) + heightHalf];
-  return p;
-}
-
-/**
- * @param a
- * @returns
- */
-function lengthVector(a: { x: number; y: number; z: number }): number {
-  return Math.sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
-}
-function normalizeVector(a: { x: number; y: number; z: number }): { x: number; y: number; z: number } {
-  const len = lengthVector(a);
-  if (len === 0) return a;
-  return {
-    x: a.x / len,
-    y: a.y / len,
-    z: a.z / len,
-  };
-}
-
-function crossVectors(a, b) {
-  const ax = a.x,
-    ay = a.y,
-    az = a.z;
-  const bx = b.x,
-    by = b.y,
-    bz = b.z;
-
-  return {
-    x: ay * bz - az * by,
-    y: az * bx - ax * bz,
-    z: ax * by - ay * bx,
-  };
-}
-
-function normalizedProjection(
-  width,
-  height,
-  nearClipPlaneDist,
-  farClipPlaneDist,
-  normalizedCenter,
-  normalizedWidth,
-  normalizedHeight,
-  normalizedDepth
-) {
-  const mtx = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-
-  mtx[0] = -normalizedWidth / width;
-  mtx[1] = 0;
-  mtx[2] = 0.0;
-  mtx[3] = normalizedCenter.x;
-
-  mtx[4] = 0.0;
-  mtx[5] = -normalizedHeight / height;
-  mtx[6] = 0.0;
-  mtx[7] = normalizedCenter.y;
-
-  mtx[8] = 0;
-  mtx[9] = 0.0;
-  mtx[10] = normalizedDepth / (farClipPlaneDist - nearClipPlaneDist);
-  mtx[11] = -mtx[10] * nearClipPlaneDist;
-
-  mtx[12] = mtx[13] = mtx[14] = 0.0;
-  mtx[15] = 1.0;
-
-  return mtx;
-}
-
-export function createOrthoProjectionMatrix(camera, width, height) {
-  const nearClipPlaneDist = 0.1;
-  const farClipPlaneDist = 1000;
-  const fieldWidth = camera.field_width;
-  const fieldHeight = camera.field_height;
-  let viewportNormalizedWidth = 2;
-  let viewportNormalizedHeight = 2;
-
-  if (width > height) {
-    const aspect = height / width;
-    const aspectFiled = fieldHeight / fieldWidth;
-    viewportNormalizedWidth = (2 / aspectFiled) * aspect;
-    viewportNormalizedHeight = 2;
-  } else {
-    const aspect = width / height;
-    const aspectFiled = fieldWidth / fieldHeight;
-    viewportNormalizedWidth = 2;
-    viewportNormalizedHeight = (2 / aspectFiled) * aspect;
-  }
-
-  const viewportNormalizedCenter = {
-    x: 0,
-    y: 0,
-  };
-
-  const projectionMatrix = normalizedProjection(
-    fieldWidth,
-    fieldHeight,
-    nearClipPlaneDist,
-    farClipPlaneDist,
-    viewportNormalizedCenter,
-    viewportNormalizedWidth,
-    viewportNormalizedHeight,
-    1.0
-  );
-
-  return projectionMatrix;
-}
-
-export function createViewMatrix(camera) {
-  const position = camera.view_point;
-
-  const viewMatrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, position.x, position.y, position.z, 1];
-
-  const target = addVectors(camera.direction, position);
-
-  matrixLookAt(viewMatrix, position, target, camera.up_vector);
-
-  return viewMatrix;
-}
-
-export function bcfWorldToScreenFromCamera(
-  camera,
-  canvas: HTMLCanvasElement,
-  point: [x: number, y: number, z: number]
-) {
-  const { width, height } = canvas;
-
-  if (lengthVector(camera.direction) >= 1.0001) {
-    camera = {
-      ...camera,
-      direction: normalizeVector(subVectors(camera.direction, camera.view_point)),
-    };
-  }
-
-  const projectionMatrix = createOrthoProjectionMatrix(camera, width, height);
-  const viewMatrix = createViewMatrix(camera);
-
-  return worldToScreen(viewMatrix, projectionMatrix, point, width, height);
-}
-
-function subVectors(
-  a: { x: number; y: number; z: number },
-  b: { x: number; y: number; z: number }
-): { x: number; y: number; z: number } {
-  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-}
-
-function addVectors(
-  a: { x: number; y: number; z: number },
-  b: { x: number; y: number; z: number }
-): { x: number; y: number; z: number } {
-  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-}
-
-export function matrixLookAt(matrix, eye, target, up) {
-  let z = subVectors(eye, target);
-
-  if (lengthVector(z) === 0) {
-    z.z = 1;
-  }
-  z = normalizeVector(z);
-
-  let x = crossVectors(z, up);
-  if (lengthVector(x) === 0) {
-    if (Math.abs(up.z) === 1) {
-      z.x += 0.0001;
-    } else {
-      z.z += 0.0001;
-    }
-
-    z = normalizeVector(z);
-
-    x = crossVectors(up, z);
-  }
-
-  x = normalizeVector(x);
-
-  const y = crossVectors(z, x);
-
-  const m = matrix;
-
-  m[0] = x.x;
-  m[4] = y.x;
-  m[8] = z.x;
-  m[1] = x.y;
-  m[5] = y.y;
-  m[9] = z.y;
-  m[2] = x.z;
-  m[6] = y.z;
-  m[10] = z.z;
-
-  return m;
-}