fl-web-component 2.0.19 → 2.1.1-beta.0

package/packages/utils/StreamLoaderParser.worker.js

@@ -88,8 +88,11 @@ function createStreamState(prefixIdKey) {
   return {
     prefixIdKey: prefixIdKey || '',
     buffer: new Uint8Array(),
-    pendingPrimitives: new Map(),
-    expectingPrimitive: true,
+    pendingMesh: null,
+    pendingPrimitiveIds: new Set(),
+    pendingPrimitiveGroups: [],
+    pendingMatchedPrimitiveIds: new Set(),
+    expectingMesh: true,
     isFullProps: true,
   };
 }
@@ -105,101 +108,179 @@ function parseStreamChunk(state, chunkView, flushing = false) {
   const meshes = [];
   const primitives = [];
 
-  while (state.buffer.length > 0) {
-    if (state.expectingPrimitive) {
-      if (state.buffer.length < 12) break;
+  const commitPendingMesh = () => {
+    if (!state.pendingMesh) return;
 
-      try {
-        const dataView = new DataView(
-          state.buffer.buffer,
-          state.buffer.byteOffset,
-          state.buffer.byteLength
-        );
-        const primitiveResult = parsePrimitive(dataView, state.buffer, 0, state.isFullProps);
-        const primitiveData = primitiveResult.primitive;
-
-        _applyPrefixId(primitiveData, 'id', null, state.prefixIdKey);
-        _applyPrefixId(primitiveData, 'material', null, state.prefixIdKey);
-
-        if (state.isFullProps) {
-          const { position, normal, posindex, nolindex, indices } =
-            parsePrimitiveData(primitiveData);
-          const formatted = formatPrimitiveData({ position, normal, posindex, nolindex });
-          delete primitiveData.nolindex;
-          delete primitiveData.posindex;
-          primitiveData.position = formatted.position;
-          primitiveData.normal = formatted.normal;
-          primitiveData.indices = indices;
-        }
+    const meshList = Array.isArray(state.pendingMesh) ? state.pendingMesh : [state.pendingMesh];
+    meshList.forEach(mesh => {
+      meshes.push(mesh);
+      primitives.push(state.pendingPrimitiveGroups);
+    });
 
-        state.pendingPrimitives.set(primitiveData.id, primitiveData);
-        state.expectingPrimitive = false;
-        state.buffer = state.buffer.slice(primitiveResult.offset);
-      } catch (e) {
+    state.pendingMesh = null;
+    state.pendingPrimitiveIds = new Set();
+    state.pendingPrimitiveGroups = [];
+    state.pendingMatchedPrimitiveIds = new Set();
+  };
+
+  while (state.buffer.length > 0) {
+    if (state.expectingMesh) {
+      const meshResult = tryParseMeshFromState(state);
+      if (meshResult.status === 'incomplete') break;
+      if (meshResult.status === 'invalid') {
         break;
       }
-    } else {
-      if (state.buffer.length < 4) break;
 
-      const length = new DataView(state.buffer.buffer, state.buffer.byteOffset).getUint32(0, false);
-      if (length > 10 * 1024 * 1024) {
-        state.expectingPrimitive = true;
+      commitPendingMesh();
+      state.pendingMesh = meshResult.mesh;
+      state.pendingPrimitiveIds = new Set(collectMeshPrimitiveIds(meshResult.mesh));
+      state.pendingPrimitiveGroups = [];
+      state.pendingMatchedPrimitiveIds = new Set();
+      state.expectingMesh = false;
+      state.buffer = state.buffer.slice(meshResult.totalLen);
+    } else {
+      const nextMeshResult = tryParseMeshFromState(state);
+      if (nextMeshResult.status === 'success') {
+        commitPendingMesh();
+        state.pendingMesh = nextMeshResult.mesh;
+        state.pendingPrimitiveIds = new Set(collectMeshPrimitiveIds(nextMeshResult.mesh));
+        state.pendingPrimitiveGroups = [];
+        state.pendingMatchedPrimitiveIds = new Set();
+        state.expectingMesh = false;
+        state.buffer = state.buffer.slice(nextMeshResult.totalLen);
         continue;
       }
 
-      const totalLen = 4 + length;
-      if (state.buffer.length < totalLen) break;
-
-      const data = state.buffer.slice(4, totalLen);
-      let mesh = null;
+      if (state.buffer.length < 12) break;
 
+      let primitiveResult = null;
       try {
-        const jsonStr = utf8Decoder.decode(data);
-        mesh = JSON.parse(jsonStr);
+        primitiveResult = parsePrimitiveFromState(state);
       } catch (e) {
-        state.expectingPrimitive = true;
-        continue;
+        break;
       }
 
-      if (mesh) {
-        state.isFullProps = true;
+      const primitiveData = primitiveResult.primitive;
 
-        _applyPrefixId(mesh, 'id', null, state.prefixIdKey);
-        if (Array.isArray(mesh)) {
-          mesh.forEach(item => {
-            _applyPrefixId(item.primitives, 'prmid', item.documentId, state.prefixIdKey);
-          });
-        } else {
-          _applyPrefixId(mesh.primitives, 'prmid', mesh.documentId, state.prefixIdKey);
-        }
+      if (state.pendingPrimitiveIds.has(primitiveData.id)) {
+        state.pendingPrimitiveGroups.push(primitiveData);
+        state.pendingMatchedPrimitiveIds.add(primitiveData.id);
+      }
 
-        const docId = mesh.id;
-        const meshToPrimId = mesh.primitives.map(item => item.prmid);
-        const hasPendingPrimitive = meshToPrimId.some(item => state.pendingPrimitives.has(item));
-        const hasPendingMesh = state.pendingPrimitives.has(docId);
-
-        if (hasPendingMesh || hasPendingPrimitive) {
-          let primitiveData = state.pendingPrimitives.get(docId);
-          if (!hasPendingMesh && hasPendingPrimitive) {
-            primitiveData = state.pendingPrimitives.get(meshToPrimId[0]);
-          }
-          meshes.push(mesh);
-          primitives.push(primitiveData);
-        }
+      state.buffer = state.buffer.slice(primitiveResult.consumedBytes);
 
-        state.expectingPrimitive = false;
-        state.buffer = state.buffer.slice(totalLen);
+      if (
+        state.pendingPrimitiveIds.size > 0 &&
+        state.pendingMatchedPrimitiveIds.size >= state.pendingPrimitiveIds.size
+      ) {
+        commitPendingMesh();
+        state.expectingMesh = true;
       }
     }
   }
 
   if (flushing) {
+    commitPendingMesh();
     state.buffer = new Uint8Array();
   }
 
   return { meshes, primitives };
 }
 
+function normalizeStreamMesh(mesh, prefixIdKey) {
+  _applyPrefixId(mesh, 'id', null, prefixIdKey);
+  const meshList = Array.isArray(mesh) ? mesh : [mesh];
+
+  meshList.forEach(item => {
+    if (!item) return;
+    if (!Array.isArray(item.primitives)) {
+      item.primitives = [];
+    }
+    _applyPrefixId(item.primitives, 'prmid', item.documentId, prefixIdKey);
+  });
+
+  return mesh;
+}
+
+function collectMeshPrimitiveIds(mesh) {
+  const ids = [];
+  const meshList = Array.isArray(mesh) ? mesh : [mesh];
+
+  meshList.forEach(item => {
+    if (!item || !Array.isArray(item.primitives)) return;
+    item.primitives.forEach(primitive => {
+      if (primitive && primitive.prmid != null) {
+        ids.push(primitive.prmid);
+      }
+    });
+  });
+
+  return ids;
+}
+
+function isValidStreamMesh(mesh) {
+  const meshList = Array.isArray(mesh) ? mesh : [mesh];
+  if (meshList.length === 0) return false;
+  return meshList.every(item => item && typeof item === 'object' && Array.isArray(item.primitives));
+}
+
+function tryParseMeshFromState(state) {
+  if (state.buffer.length < 4) {
+    return { status: 'incomplete' };
+  }
+
+  const length = new DataView(state.buffer.buffer, state.buffer.byteOffset).getUint32(0, false);
+  if (length <= 0 || length > 10 * 1024 * 1024) {
+    return { status: 'invalid' };
+  }
+
+  const totalLen = 4 + length;
+  if (state.buffer.length < totalLen) {
+    return { status: 'incomplete' };
+  }
+
+  try {
+    const data = state.buffer.slice(4, totalLen);
+    const parsedMesh = JSON.parse(utf8Decoder.decode(data));
+    if (!isValidStreamMesh(parsedMesh)) {
+      return { status: 'invalid' };
+    }
+    const mesh = normalizeStreamMesh(parsedMesh, state.prefixIdKey);
+    return { status: 'success', mesh, totalLen };
+  } catch (e) {
+    return { status: 'invalid' };
+  }
+}
+
+function parsePrimitiveFromState(state) {
+  const dataView = new DataView(
+    state.buffer.buffer,
+    state.buffer.byteOffset,
+    state.buffer.byteLength
+  );
+  const primitiveResult = parsePrimitive(dataView, state.buffer, 0, state.isFullProps);
+  const primitiveData = primitiveResult.primitive;
+
+  _applyPrefixId(primitiveData, 'id', null, state.prefixIdKey);
+  _applyPrefixId(primitiveData, 'material', null, state.prefixIdKey);
+
+  if (state.isFullProps) {
+    const { position, normal, posindex, nolindex, indices } =
+      parsePrimitiveData(primitiveData);
+    const formatted = formatPrimitiveData({ position, normal, posindex, nolindex });
+    delete primitiveData.nolindex;
+    delete primitiveData.posindex;
+    primitiveData.position = formatted.position;
+    primitiveData.normal = formatted.normal;
+    primitiveData.indices = indices;
+  }
+
+  return {
+    primitive: primitiveData,
+    consumedBytes: primitiveResult.offset,
+  };
+}
+
 function parseBufferData(buffer, prefixIdKey) {
   let uint8Array = null;
   let dataView = null;
@@ -288,8 +369,20 @@ function parsePrimitive(dataView, uint8Array, offset, isFullProps = true) {
   if (dataView.byteLength < offset + 12) {
     throw new Error('Insufficient data for primitive header');
   }
-  primitive.id = dataView.getInt32(offset, false);
+  const primitiveIdTextLen = dataView.getUint32(offset, false);
   offset += 4;
+  if (primitiveIdTextLen === 0xffffffff) {
+    primitive.id = null;
+  } else if (primitiveIdTextLen > 0) {
+    if (dataView.byteLength < offset + primitiveIdTextLen) {
+      throw new Error('Insufficient data for primitive id content');
+    }
+    const textBytes = uint8Array.subarray(offset, offset + primitiveIdTextLen);
+    primitive.id = utf8Decoder.decode(textBytes);
+    offset += primitiveIdTextLen;
+  } else {
+    primitive.id = '';
+  }
 
   if (dataView.byteLength < offset + 4) {
     throw new Error('Insufficient data for GeomText length');
@@ -309,8 +402,23 @@ function parsePrimitive(dataView, uint8Array, offset, isFullProps = true) {
     primitive.documentId = '';
   }
 
-  primitive.material = dataView.getInt32(offset, false);
+  if (dataView.byteLength < offset + 4) {
+    throw new Error('Insufficient data for Material length');
+  }
+  const materialTextLen = dataView.getUint32(offset, false);
   offset += 4;
+  if (materialTextLen === 0xffffffff) {
+    primitive.material = null;
+  } else if (materialTextLen > 0) {
+    if (dataView.byteLength < offset + materialTextLen) {
+      throw new Error('Insufficient data for Material content');
+    }
+    const textBytes = uint8Array.subarray(offset, offset + materialTextLen);
+    primitive.material = utf8Decoder.decode(textBytes);
+    offset += materialTextLen;
+  } else {
+    primitive.material = '';
+  }
 
   if (dataView.byteLength < offset + 4) {
     throw new Error('Insufficient data for GeomText length');

package/src/utils/dxf-parser/AutoCadColorIndex.js

@@ -0,0 +1,265 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+
+export default [
+ 0,
+ 16711680,
+ 16776960,
+ 65280,
+ 65535,
+ 255,
+ 16711935,
+ 16777215,
+ 8421504,
+ 12632256,
+ 16711680,
+ 16744319,
+ 13369344,
+ 13395558,
+ 10027008,
+ 10046540,
+ 8323072,
+ 8339263,
+ 4980736,
+ 4990502,
+ 16727808,
+ 16752511,
+ 13382400,
+ 13401958,
+ 10036736,
+ 10051404,
+ 8331008,
+ 8343359,
+ 4985600,
+ 4992806,
+ 16744192,
+ 16760703,
+ 13395456,
+ 13408614,
+ 10046464,
+ 10056268,
+ 8339200,
+ 8347455,
+ 4990464,
+ 4995366,
+ 16760576,
+ 16768895,
+ 13408512,
+ 13415014,
+ 10056192,
+ 10061132,
+ 8347392,
+ 8351551,
+ 4995328,
+ 4997670,
+ 16776960,
+ 16777087,
+ 13421568,
+ 13421670,
+ 10000384,
+ 10000460,
+ 8355584,
+ 8355647,
+ 5000192,
+ 5000230,
+ 12582656,
+ 14679935,
+ 10079232,
+ 11717734,
+ 7510016,
+ 8755276,
+ 6258432,
+ 7307071,
+ 3755008,
+ 4344870,
+ 8388352,
+ 12582783,
+ 6736896,
+ 10079334,
+ 5019648,
+ 7510092,
+ 4161280,
+ 6258495,
+ 2509824,
+ 3755046,
+ 4194048,
+ 10485631,
+ 3394560,
+ 8375398,
+ 2529280,
+ 6264908,
+ 2064128,
+ 5209919,
+ 1264640,
+ 3099686,
+ 65280,
+ 8388479,
+ 52224,
+ 6736998,
+ 38912,
+ 5019724,
+ 32512,
+ 4161343,
+ 19456,
+ 2509862,
+ 65343,
+ 8388511,
+ 52275,
+ 6737023,
+ 38950,
+ 5019743,
+ 32543,
+ 4161359,
+ 19475,
+ 2509871,
+ 65407,
+ 8388543,
+ 52326,
+ 6737049,
+ 38988,
+ 5019762,
+ 32575,
+ 4161375,
+ 19494,
+ 2509881,
+ 65471,
+ 8388575,
+ 52377,
+ 6737074,
+ 39026,
+ 5019781,
+ 32607,
+ 4161391,
+ 19513,
+ 2509890,
+ 65535,
+ 8388607,
+ 52428,
+ 6737100,
+ 39064,
+ 5019800,
+ 32639,
+ 4161407,
+ 19532,
+ 2509900,
+ 49151,
+ 8380415,
+ 39372,
+ 6730444,
+ 29336,
+ 5014936,
+ 24447,
+ 4157311,
+ 14668,
+ 2507340,
+ 32767,
+ 8372223,
+ 26316,
+ 6724044,
+ 19608,
+ 5010072,
+ 16255,
+ 4153215,
+ 9804,
+ 2505036,
+ 16383,
+ 8364031,
+ 13260,
+ 6717388,
+ 9880,
+ 5005208,
+ 8063,
+ 4149119,
+ 4940,
+ 2502476,
+ 255,
+ 8355839,
+ 204,
+ 6710988,
+ 152,
+ 5000344,
+ 127,
+ 4145023,
+ 76,
+ 2500172,
+ 4129023,
+ 10452991,
+ 3342540,
+ 8349388,
+ 2490520,
+ 6245528,
+ 2031743,
+ 5193599,
+ 1245260,
+ 3089996,
+ 8323327,
+ 12550143,
+ 6684876,
+ 10053324,
+ 4980888,
+ 7490712,
+ 4128895,
+ 6242175,
+ 2490444,
+ 3745356,
+ 12517631,
+ 14647295,
+ 10027212,
+ 11691724,
+ 7471256,
+ 8735896,
+ 6226047,
+ 7290751,
+ 3735628,
+ 4335180,
+ 16711935,
+ 16744447,
+ 13369548,
+ 13395660,
+ 9961624,
+ 9981080,
+ 8323199,
+ 8339327,
+ 4980812,
+ 4990540,
+ 16711871,
+ 16744415,
+ 13369497,
+ 13395634,
+ 9961586,
+ 9981061,
+ 8323167,
+ 8339311,
+ 4980793,
+ 4990530,
+ 16711807,
+ 16744383,
+ 13369446,
+ 13395609,
+ 9961548,
+ 9981042,
+ 8323135,
+ 8339295,
+ 4980774,
+ 4990521,
+ 16711743,
+ 16744351,
+ 13369395,
+ 13395583,
+ 9961510,
+ 9981023,
+ 8323103,
+ 8339279,
+ 4980755,
+ 4990511,
+ 3355443,
+ 5987163,
+ 8684676,
+ 11382189,
+ 14079702,
+ 16777215
+];

package/src/utils/dxf-parser/DimStyleCodes.js

@@ -0,0 +1,33 @@
+/** Dimension style variables are used either in DIMSTYLE table or in DIMENSION entity style
+ * override in XDATA.
+ */
+const codes = new Map([
+    [140, "DIMTXT"],
+    [142, "DIMTSZ"],
+    [144, "DIMLFAC"],
+    [147, "DIMGAP"],
+    [173, "DIMSAH"],
+    [175, "DIMSOXD"],
+    [176, "DIMCLRD"],
+    [177, "DIMCLRE"],
+    [178, "DIMCLRT"],
+    [271, "DIMDEC"],
+    [278 ,"DIMDSEP"],
+    [281, "DIMSD1"],
+    [282, "DIMSD2"],
+    [3, "DIMPOST"],
+    [40, "DIMSCALE"],
+    [41, "DIMASZ"],
+    [42, "DIMEXO"],
+    [44, "DIMEXE"],
+    [45, "DIMRND"],
+    [46, "DIMDLE"],
+    [5, "DIMBLK"],
+    [6, "DIMBLK1"],
+    [7, "DIMBLK2"],
+    [75, "DIMSE1"],
+    [76, "DIMSE2"],
+    [78, "DIMZIN"],
+])
+
+export default codes