@mlightcad/libredwg-web 0.6.10 → 0.7.1

package/lib/converter/entityConverter.js

@@ -1,4 +1,4 @@
-import { DwgBoundaryPathEdgeType, DwgHatchAssociativity, DwgHatchSolidFill } from '../database';
+import { DwgBoundaryPathEdgeType, DwgHatchAssociativity, DwgHatchGradientColorFlag, DwgHatchGradientFlag, DwgHatchSolidFill } from '../database';
 import { Dwg_Hatch_Edge_Type, Dwg_Object_Type } from '../types';
 import { idToString } from './utils';
 export class LibreEntityConverter {
@@ -483,8 +483,7 @@ export class LibreEntityConverter {
         const seedPoints_ptr = libredwg.dwg_dynapi_entity_value(entity, 'seeds')
             .data;
         const seedPoints = libredwg.dwg_ptr_to_point2d_array(seedPoints_ptr, numberOfSeedPoints);
-        return {
-            type: 'HATCH',
+        const result = {
             ...commonAttrs,
             // elevationPoint: DwgPoint3D
             extrusionDirection: extrusionDirection,
@@ -518,6 +517,42 @@ export class LibreEntityConverter {
             seedPoints: seedPoints
             // gradientFlag?: DwgHatchGradientFlag
         };
+        const gradientFlag = libredwg.dwg_dynapi_entity_value(entity, 'is_gradient_fill')
+            .data;
+        if (gradientFlag > 0) {
+            const gradientName = libredwg.dwg_dynapi_entity_value(entity, 'gradient_name')
+                .data;
+            const gradientRotation = libredwg.dwg_dynapi_entity_value(entity, 'gradient_angle')
+                .data;
+            const gradientDefinition = libredwg.dwg_dynapi_entity_value(entity, 'gradient_shift')
+                .data;
+            const colorTint = libredwg.dwg_dynapi_entity_value(entity, 'gradient_tint')
+                .data;
+            const gradientColorFlag = libredwg.dwg_dynapi_entity_value(entity, 'single_color_gradient')
+                .data;
+            // const numberOfColors = libredwg.dwg_dynapi_entity_value(entity, 'num_colors')
+            //   .data as number
+            const gradientColors_ptr = libredwg.dwg_dynapi_entity_value(entity, 'colors')
+                .data;
+            const gradientColors = libredwg.dwg_ptr_to_hatch_gradient_color_array(gradientColors_ptr, (gradientColorFlag == 1) ? 1 : 2);
+            return {
+                type: 'HATCH',
+                ...result,
+                gradientFlag: DwgHatchGradientFlag.Gradient,
+                gradientColorFlag: gradientColorFlag == 1 ? DwgHatchGradientColorFlag.OneColor : DwgHatchGradientColorFlag.TwoColor,
+                gradientName,
+                gradientRotation,
+                gradientDefinition,
+                colorTint,
+                gradientColors
+            };
+        }
+        else {
+            return {
+                type: 'HATCH',
+                ...result
+            };
+        }
     }
     convertHatchBoundaryPaths(paths) {
         const converted = paths

package/lib/database/entities/hatch.d.ts

@@ -124,13 +124,20 @@ export interface DwgHatchEntityBase extends DwgEntity {
     seedPoints?: DwgPoint2D[];
     gradientFlag?: DwgHatchGradientFlag;
 }
+export interface DwgGradientColor {
+    reservedData: number;
+    rgb: number;
+    colorIndex?: number;
+}
 export interface DwgGradientHatchEntity extends DwgHatchEntityBase {
+    gradientName: string;
     gradientFlag: DwgHatchGradientFlag.Gradient;
     gradientColorFlag: DwgHatchGradientColorFlag;
     numberOfColors: 0 | 2;
     gradientRotation?: number;
     gradientDefinition: number;
     colorTint?: number;
+    gradientColors?: Array<DwgGradientColor>;
 }
 export type DwgHatchEntity = DwgGradientHatchEntity | DwgHatchEntityBase;
 export {};

package/lib/libredwg.d.ts

@@ -1,6 +1,6 @@
 import { MainModule } from '../wasm/libredwg-web';
 import createModule from '../wasm/libredwg-web.js';
-import { DwgCodePage, DwgDatabase, DwgPoint2D, DwgPoint3D, DwgPoint4D, DwgVersion, DwgXData } from './database';
+import { DwgCodePage, DwgDatabase, DwgGradientColor, DwgPoint2D, DwgPoint3D, DwgPoint4D, DwgVersion, DwgXData } from './database';
 import { Dwg_Array_Ptr, Dwg_Class, Dwg_Color, Dwg_Data_Ptr, Dwg_Entity_BLOCK, Dwg_Entity_IMAGE_Ptr, Dwg_Entity_LWPOLYLINE_Ptr, Dwg_Entity_MTEXT_Ptr, Dwg_Entity_POLYLINE_2D_Ptr, Dwg_Entity_POLYLINE_3D_Ptr, Dwg_Entity_TEXT_Ptr, Dwg_Entity_VERTEX_2D, Dwg_Entity_VERTEX_3D, Dwg_Field_Value, Dwg_Handle, Dwg_HATCH_DefLine, Dwg_HATCH_Path, Dwg_LTYPE_Dash, Dwg_MLINE_Vertex, Dwg_Object_BLOCK_HEADER_Ptr, Dwg_Object_BLOCK_Ptr, Dwg_Object_DIMSTYLE_Ptr, Dwg_Object_Entity_Ptr, Dwg_Object_Entity_TIO_Ptr, Dwg_Object_Generic_Ptr, Dwg_Object_IMAGEDEF_Ptr, Dwg_Object_LAYER_Ptr, Dwg_Object_LTYPE_Ptr, Dwg_Object_Object_Ptr, Dwg_Object_Object_TIO_Ptr, Dwg_Object_Ptr, Dwg_Object_Ref, Dwg_Object_Ref_Ptr, Dwg_Object_STYLE_Ptr, Dwg_Object_Type, Dwg_Object_VERTEX_2D_Ptr, Dwg_Object_VERTEX_3D_Ptr, Dwg_Object_VPORT_Ptr, Dwg_TABLE_Cell } from './types';
 export { createModule };
 export type LibreDwgEx = LibreDwg & MainModule;
@@ -19,6 +19,12 @@ export declare class LibreDwg {
     private decoder?;
     private constructor();
     dwg_read_data(fileContent: string | ArrayBuffer, fileType: number): number | undefined;
+    /**
+     * Converts DWG file content to DXF file content.
+     * @param fileContent DWG file content.
+     * @returns Returns DXF file content if conversion succeeds. Otherwise returns null.
+     */
+    dwg_write_dxf(fileContent: string | ArrayBuffer): Uint8Array | null;
     /**
      * Gets the version of the dwg.
      * @param data Pointer to Dwg_Data instance.
@@ -472,6 +478,15 @@ export declare class LibreDwg {
      * @returns Returns one JavaScript hatch path array from the specified C++ hatch path array.
      */
     dwg_ptr_to_hatch_path_array(ptr: Dwg_Array_Ptr, size: number): Dwg_HATCH_Path[];
+    /**
+     * Converts one C++ hatch gradient color array to one JavaScript hatch gradient color array.
+     * @group Array Methods
+     * @group Dwg_Entity_HATCH Methods
+     * @param ptr Pointer to C++ hatch gradient color array.
+     * @param size The size of C++ hatch gradient color array.
+     * @returns Returns one JavaScript hatch gradient color array from the specified C++ hatch gradient color array.
+     */
+    dwg_ptr_to_hatch_gradient_color_array(ptr: Dwg_Array_Ptr, size: number): DwgGradientColor[];
     /**
      * Converts one C++ mline vertex array to one JavaScript mline vertex array.
      * @group Array Methods

package/lib/libredwg.js

@@ -29,13 +29,19 @@ export class LibreDwg {
     dwg_read_data(fileContent, fileType) {
         if (fileType == Dwg_File_Type.DWG) {
             const fileName = 'tmp.dwg';
-            this.wasmInstance.FS.writeFile(fileName, new Uint8Array(fileContent));
-            const result = this.wasmInstance.dwg_read_file(fileName);
-            if (result.error != 0) {
-                console.log('Open dwg file with error code: ', result.error);
+            try {
+                this.wasmInstance.FS.writeFile(fileName, new Uint8Array(fileContent));
+                const result = this.wasmInstance.dwg_read_file(fileName);
+                if (result.error != 0) {
+                    console.log('Open dwg file with error code: ', result.error);
+                }
+                return result.data;
+            }
+            finally {
+                if (this.wasmInstance.FS.analyzePath(fileName, false).exists) {
+                    this.wasmInstance.FS.unlink(fileName);
+                }
             }
-            this.wasmInstance.FS.unlink(fileName);
-            return result.data;
         }
         // else if (fileType == Dwg_File_Type.DXF) {
         //   const fileName = "tmp.dxf";
@@ -48,6 +54,32 @@ export class LibreDwg {
         //   return result.data as Dwg_Data_Ptr;
         // }
     }
+    /**
+     * Converts DWG file content to DXF file content.
+     * @param fileContent DWG file content.
+     * @returns Returns DXF file content if conversion succeeds. Otherwise returns null.
+     */
+    dwg_write_dxf(fileContent) {
+        const inputFileName = 'tmp.dwg';
+        const outputFileName = 'tmp.dxf';
+        try {
+            this.wasmInstance.FS.writeFile(inputFileName, new Uint8Array(fileContent));
+            const error = this.wasmInstance.dwg_write_dxf(inputFileName, outputFileName);
+            if (error != 0) {
+                console.log('Convert dwg to dxf with error code: ', error);
+                return null;
+            }
+            return this.wasmInstance.FS.readFile(outputFileName);
+        }
+        finally {
+            if (this.wasmInstance.FS.analyzePath(inputFileName, false).exists) {
+                this.wasmInstance.FS.unlink(inputFileName);
+            }
+            if (this.wasmInstance.FS.analyzePath(outputFileName, false).exists) {
+                this.wasmInstance.FS.unlink(outputFileName);
+            }
+        }
+    }
     /**
      * Gets the version of the dwg.
      * @param data Pointer to Dwg_Data instance.
@@ -665,6 +697,17 @@ export class LibreDwg {
     dwg_ptr_to_hatch_path_array(ptr, size) {
         return this.wasmInstance.dwg_ptr_to_hatch_path_array(ptr, size);
     }
+    /**
+     * Converts one C++ hatch gradient color array to one JavaScript hatch gradient color array.
+     * @group Array Methods
+     * @group Dwg_Entity_HATCH Methods
+     * @param ptr Pointer to C++ hatch gradient color array.
+     * @param size The size of C++ hatch gradient color array.
+     * @returns Returns one JavaScript hatch gradient color array from the specified C++ hatch gradient color array.
+     */
+    dwg_ptr_to_hatch_gradient_color_array(ptr, size) {
+        return this.wasmInstance.dwg_ptr_to_hatch_gradient_color_array(ptr, size);
+    }
     /**
      * Converts one C++ mline vertex array to one JavaScript mline vertex array.
      * @group Array Methods

package/package.json

@@ -3,7 +3,7 @@
   "description": "A DWG/DXF JavaScript parser based on libredwg",
   "license": "GPL-3.0",
   "private": false,
-  "version": "0.6.10",
+  "version": "0.7.1",
   "author": "MLight Lee <mlight.lee@outlook.com>",
   "type": "module",
   "repository": {
@@ -70,7 +70,7 @@
     "demo": "live-server examples --entry-file=index.html",
     "doc": "typedoc",
     "build": "tsc && vite build && cp -rf wasm examples/ && cp -rf dist examples/",
-    "build:prepare": "mkdir -p ../../build-wasm && cd ../../build-wasm && emconfigure ../configure CFLAGS=\"-O2 -sUSE_ZLIB=1\" CC=emcc --enable-release --disable-docs --disable-write --disable-python --disable-bindings --disable-shared --disable-json --disable-dxf --enable-partial --enable-experimental",
+    "build:prepare": "mkdir -p ../../build-wasm && cd ../../build-wasm && emconfigure ../configure CFLAGS=\"-O2 -sUSE_ZLIB=1\" CC=emcc --enable-release --disable-docs --disable-write --disable-python --disable-bindings --disable-shared --disable-json --enable-partial --enable-experimental",
     "build:obj": "cd ../../build-wasm && emmake make",
     "build:wasm": "cd ../../build-wasm && emcc ../bindings/javascript/embind/*.cpp src/*.o -O2 -lembind -std=c++17 -Isrc -I../src -I../include -o libredwg-web.js -s ALLOW_MEMORY_GROWTH=1 -s EXPORT_ES6=1 -s MODULARIZE=1 -s EXPORT_NAME=\"createModule\" -sEXPORTED_RUNTIME_METHODS=FS,ENV,ccall,cwrap,UTF8ToString,stringToNewUTF8,setValue --emit-tsd libredwg-web.d.ts",
     "clean": "rm -rf ../../build-wasm ./docs ./dist ./lib",

package/wasm/libredwg-web.d.ts

@@ -10,9 +10,10 @@ declare namespace RuntimeExports {
         export let currentPath: string;
         export let initialized: boolean;
         export let ignorePermissions: boolean;
+        export { ErrnoError };
         export let filesystems: any;
         export let syncFSRequests: number;
-        export { ErrnoError };
+        export let readFiles: {};
         export { FSStream };
         export { FSNode };
         export function lookupPath(path: any, opts?: {}): {
@@ -113,10 +114,11 @@ declare namespace RuntimeExports {
         export function llseek(stream: any, offset: any, whence: any): any;
         export function read(stream: any, buffer: any, offset: any, length: any, position: any): any;
         export function write(stream: any, buffer: any, offset: any, length: any, position: any, canOwn: any): any;
+        export function allocate(stream: any, offset: any, length: any): void;
         export function mmap(stream: any, length: any, position: any, prot: any, flags: any): any;
         export function msync(stream: any, buffer: any, offset: any, length: any, mmapFlags: any): any;
         export function ioctl(stream: any, cmd: any, arg: any): any;
-        export function readFile(path: any, opts?: {}): Uint8Array<any>;
+        export function readFile(path: any, opts?: {}): any;
         export function writeFile(path: any, data: any, opts?: {}): void;
         export function cwd(): any;
         export function chdir(path: any): void;
@@ -150,10 +152,10 @@ declare namespace RuntimeExports {
     /**
      * @param {string|null=} returnType
      * @param {Array=} argTypes
-     * @param {Array=} args
+     * @param {Arguments|Array=} args
      * @param {Object=} opts
      */
-    function ccall(ident: any, returnType?: (string | null) | undefined, argTypes?: any[] | undefined, args?: any[] | undefined, opts?: any | undefined): any;
+    function ccall(ident: any, returnType?: (string | null) | undefined, argTypes?: any[] | undefined, args?: (Arguments | any[]) | undefined, opts?: any | undefined): any;
     /**
      * @param {string=} returnType
      * @param {Array=} argTypes
@@ -169,11 +171,13 @@ declare namespace RuntimeExports {
      *   maximum number of bytes to read. You can omit this parameter to scan the
      *   string until the first 0 byte. If maxBytesToRead is passed, and the string
      *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
-     *   string will cut short at that byte index.
-     * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
+     *   string will cut short at that byte index (i.e. maxBytesToRead will not
+     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+     *   JS JIT optimizations off, so it is worth to consider consistently using one
      * @return {string}
      */
-    function UTF8ToString(ptr: number, maxBytesToRead?: number | undefined, ignoreNul?: boolean | undefined): string;
+    function UTF8ToString(ptr: number, maxBytesToRead?: number | undefined): string;
     function stringToNewUTF8(str: any): any;
     /**
      * @param {number} ptr
@@ -181,6 +185,17 @@ declare namespace RuntimeExports {
      * @param {string} type
      */
     function setValue(ptr: number, value: number, type?: string): void;
+    let HEAPF32: any;
+    let HEAPF64: any;
+    let HEAP_DATA_VIEW: any;
+    let HEAP8: any;
+    let HEAPU8: any;
+    let HEAP16: any;
+    let HEAPU16: any;
+    let HEAP32: any;
+    let HEAPU32: any;
+    let HEAP64: any;
+    let HEAPU64: any;
 }
 declare class ErrnoError {
     constructor(errno: any);
@@ -232,8 +247,6 @@ export interface ClassHandle {
   delete(): void;
   deleteLater(): this;
   isDeleted(): boolean;
-  // @ts-ignore - If targeting lower than ESNext, this symbol might not exist.
-  [Symbol.dispose](): void;
   clone(): this;
 }
 export interface Dwg_Version_TypeValue<T extends number> {
@@ -426,6 +439,7 @@ interface EmbindModule {
   dwg_dynapi_entity_set_value(_0: number, _1: EmbindString, _2: EmbindString, _3: number, _4: boolean): boolean;
   dwg_dynapi_common_set_value(_0: number, _1: EmbindString, _2: number, _3: boolean): boolean;
   dwg_dynapi_handle_name(_0: number, _1: number, _2: number): string;
+  dwg_write_dxf(_0: EmbindString, _1: EmbindString): number;
   dwg_find_tablehandle(_0: number, _1: EmbindString, _2: EmbindString): number;
   dwg_find_tablehandle_index(_0: number, _1: number, _2: EmbindString): number;
   dwg_handle_name(_0: number, _1: EmbindString, _2: number): string;
@@ -481,6 +495,7 @@ interface EmbindModule {
   dwg_ptr_to_table_cell_array(_0: number, _1: number): any;
   dwg_ptr_to_hatch_defline_array(_0: number, _1: number): any;
   dwg_ptr_to_hatch_path_array(_0: number, _1: number): any;
+  dwg_ptr_to_hatch_gradient_color_array(_0: number, _1: number): any;
   dwg_ptr_to_mline_vertex_array(_0: number, _1: number): any;
   dwg_object_get_name(_0: number): any;
   dwg_object_get_handle_object(_0: number): any;