sp-graph-layout 0.0.1 → 1.0.0

package/README.md

@@ -0,0 +1,21 @@
+Graph Layout
+============
+
+## Overview
+
+A library for visualizing directed graphs.
+
+|                                   rank dir = TB                                    |                                   rank dir = LR                                    |
+|:----------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------:|
+| ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example1_tb.svg) | ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example1_lr.svg) |
+| ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example2_tb.svg) | ![](https://github.com/CyberZHG/GraphLayout/blob/main/docs/images/example2_lr.svg) |
+
+## Documentation
+
+* [Documentation](https://cyberzhg.github.io/GraphLayout/)
+
+    * [Installation](https://cyberzhg.github.io/GraphLayout/install.html)
+    * [Basic Concepts](https://cyberzhg.github.io/GraphLayout/basic.html)
+    * [Graph Attributes](https://cyberzhg.github.io/GraphLayout/graph_attr.html)
+    * [Vertex Attributes](https://cyberzhg.github.io/GraphLayout/vertex_attr.html)
+    * [Edge Attributes](https://cyberzhg.github.io/GraphLayout/edge_attr.html)

package/index.js

@@ -2,12 +2,45 @@ import GraphLayoutWASMModule from './wasm/GraphLayoutWASM.js';
 
 const GraphLayoutWASM = await GraphLayoutWASMModule();
 
-const createDirectedGraph = GraphLayoutWASM.createDirectedGraph;
+const VectorString = GraphLayoutWASM.VectorString;
+
+function buildVectorString(strings) {
+    const vector = new VectorString();
+    for (const str of strings) {
+        vector.push_back(str);
+    }
+    return vector;
+}
+
+const _compareSVG = GraphLayoutWASM._compareSVG;
+const FeedbackArcsMethod = GraphLayoutWASM.FeedbackArcsMethod;
+const LayerAssignmentMethod = GraphLayoutWASM.LayerAssignmentMethod;
+const CrossMinimizationMethod = GraphLayoutWASM.CrossMinimizationMethod;
+const VertexPositioningMethod = GraphLayoutWASM.VertexPositioningMethod;
 const SPDirectedGraph = GraphLayoutWASM.SPDirectedGraph;
+const Attribute = GraphLayoutWASM.Attribute;
+const AttributeRankDir = GraphLayoutWASM.AttributeRankDir;
+const AttributeShape = GraphLayoutWASM.AttributeShape;
+const Attributes = GraphLayoutWASM.Attributes;
 const DirectedGraphHierarchicalLayout = GraphLayoutWASM.DirectedGraphHierarchicalLayout;
 
+SPDirectedGraph.prototype.addEdges = function (edges) {
+    for (const edge of edges) {
+        this.addEdge(edge[0], edge[1]);
+    }
+}
+
 export {
-    createDirectedGraph,
+    _compareSVG,
+    buildVectorString,
+    FeedbackArcsMethod,
+    LayerAssignmentMethod,
+    CrossMinimizationMethod,
+    VertexPositioningMethod,
     SPDirectedGraph,
+    Attribute,
+    AttributeRankDir,
+    AttributeShape,
+    Attributes,
     DirectedGraphHierarchicalLayout,
 };

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "sp-graph-layout",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "type": "module",
   "main": "index.js",
+  "types": "index.d.ts",
   "files": [
     "index.js",
+    "index.d.js",
     "wasm/GraphLayoutWASM.js",
     "wasm/GraphLayoutWASM.wasm"
   ],
@@ -19,5 +21,7 @@
     "build": "bash build.sh",
     "lint": "npx eslint index.js test/**/*.js",
     "test": "mocha test/**/*.js"
-  }
+  },
+  "homepage": "https://cyberzhg.github.io/GraphLayout/",
+  "repository": "github:CyberZHG/GraphLayout"
 }

package/wasm/GraphLayoutWASM.js

@@ -1934,6 +1934,77 @@ async function createWasm() {
       );
     };
 
+  
+  
+  var runDestructors = (destructors) => {
+      while (destructors.length) {
+        var ptr = destructors.pop();
+        var del = destructors.pop();
+        del(ptr);
+      }
+    };
+  
+  
+  
+  var __embind_register_class_class_property = (rawClassType,
+                                            fieldName,
+                                            rawFieldType,
+                                            rawFieldPtr,
+                                            getterSignature,
+                                            getter,
+                                            setterSignature,
+                                            setter) => {
+      fieldName = AsciiToString(fieldName);
+      getter = embind__requireFunction(getterSignature, getter);
+  
+      whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+        classType = classType[0];
+        var humanName = `${classType.name}.${fieldName}`;
+        var desc = {
+          get() {
+            throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [rawFieldType]);
+          },
+          enumerable: true,
+          configurable: true
+        };
+        if (setter) {
+          desc.set = () => {
+            throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`, [rawFieldType]);
+          };
+        } else {
+          desc.set = (v) => {
+            throwBindingError(`${humanName} is a read-only property`);
+          };
+        }
+  
+        Object.defineProperty(classType.registeredClass.constructor, fieldName, desc);
+  
+        whenDependentTypesAreResolved([], [rawFieldType], (fieldType) => {
+          fieldType = fieldType[0];
+          var desc = {
+            get() {
+              return fieldType.fromWireType(getter(rawFieldPtr));
+            },
+            enumerable: true
+          };
+  
+          if (setter) {
+            setter = embind__requireFunction(setterSignature, setter);
+            desc.set = (v) => {
+              var destructors = [];
+              setter(rawFieldPtr, fieldType.toWireType(destructors, v));
+              runDestructors(destructors);
+            };
+          }
+  
+          Object.defineProperty(classType.registeredClass.constructor, fieldName, desc);
+          return [];
+        });
+  
+        return [];
+      });
+    };
+
   var heap32VectorToArray = (count, firstElement) => {
       var array = [];
       for (var i = 0; i < count; i++) {
@@ -1947,13 +2018,6 @@ async function createWasm() {
   
   
   
-  var runDestructors = (destructors) => {
-      while (destructors.length) {
-        var ptr = destructors.pop();
-        var del = destructors.pop();
-        del(ptr);
-      }
-    };
   
   
   function usesDestructorStack(argTypes) {
@@ -2279,6 +2343,69 @@ async function createWasm() {
     };
   var __embind_register_emval = (rawType) => registerType(rawType, EmValType);
 
+  
+  var enumReadValueFromPointer = (name, width, signed) => {
+      switch (width) {
+        case 1: return signed ?
+          function(pointer) { return this.fromWireType(HEAP8[pointer]) } :
+          function(pointer) { return this.fromWireType(HEAPU8[pointer]) };
+        case 2: return signed ?
+          function(pointer) { return this.fromWireType(HEAP16[((pointer)>>1)]) } :
+          function(pointer) { return this.fromWireType(HEAPU16[((pointer)>>1)]) };
+        case 4: return signed ?
+          function(pointer) { return this.fromWireType(HEAP32[((pointer)>>2)]) } :
+          function(pointer) { return this.fromWireType(HEAPU32[((pointer)>>2)]) };
+        default:
+          throw new TypeError(`invalid integer width (${width}): ${name}`);
+      }
+    };
+  
+  
+  /** @suppress {globalThis} */
+  var __embind_register_enum = (rawType, name, size, isSigned) => {
+      name = AsciiToString(name);
+  
+      function ctor() {}
+      ctor.values = {};
+  
+      registerType(rawType, {
+        name,
+        constructor: ctor,
+        fromWireType: function(c) {
+          return this.constructor.values[c];
+        },
+        toWireType: (destructors, c) => c.value,
+        readValueFromPointer: enumReadValueFromPointer(name, size, isSigned),
+        destructorFunction: null,
+      });
+      exposePublicSymbol(name, ctor);
+    };
+
+  
+  
+  
+  
+  var requireRegisteredType = (rawType, humanName) => {
+      var impl = registeredTypes[rawType];
+      if (undefined === impl) {
+        throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+      }
+      return impl;
+    };
+  var __embind_register_enum_value = (rawEnumType, name, enumValue) => {
+      var enumType = requireRegisteredType(rawEnumType, 'enum');
+      name = AsciiToString(name);
+  
+      var Enum = enumType.constructor;
+  
+      var Value = Object.create(enumType.constructor.prototype, {
+        value: {value: enumValue},
+        constructor: {value: createNamedFunction(`${enumType.name}_${name}`, function() {})},
+      });
+      Enum.values[enumValue] = Value;
+      Enum[name] = Value;
+    };
+
   var floatReadValueFromPointer = (name, width) => {
       switch (width) {
         case 4: return function(pointer) {
@@ -2406,6 +2533,12 @@ async function createWasm() {
     };
 
   
+  var EmValOptionalType = Object.assign({optional: true}, EmValType);;
+  var __embind_register_optional = (rawOptionalType, rawType) => {
+      registerType(rawOptionalType, EmValOptionalType);
+    };
+
+  
   
   var __embind_register_smart_ptr = (rawType,
                                  rawPointeeType,
@@ -2766,15 +2899,6 @@ async function createWasm() {
       return id;
     };
   
-  
-  
-  var requireRegisteredType = (rawType, humanName) => {
-      var impl = registeredTypes[rawType];
-      if (undefined === impl) {
-        throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
-      }
-      return impl;
-    };
   var emval_lookupTypes = (argCount, argTypes) => {
       var a = new Array(argCount);
       for (var i = 0; i < argCount; ++i) {
@@ -3286,7 +3410,6 @@ Module['FS_createPreloadedFile'] = FS.createPreloadedFile;
   'unregisterInheritedInstance',
   'getInheritedInstanceCount',
   'getLiveInheritedInstances',
-  'enumReadValueFromPointer',
   'setDelayFunction',
   'validateThis',
   'count_emval_handles',
@@ -3554,6 +3677,7 @@ missingLibrarySymbols.forEach(missingLibrarySymbol)
   'registeredPointers',
   'registerType',
   'integerReadValueFromPointer',
+  'enumReadValueFromPointer',
   'floatReadValueFromPointer',
   'assertIntegerRange',
   'readPointer',
@@ -3671,12 +3795,18 @@ var wasmImports = {
   /** @export */
   _embind_register_class: __embind_register_class,
   /** @export */
+  _embind_register_class_class_property: __embind_register_class_class_property,
+  /** @export */
   _embind_register_class_constructor: __embind_register_class_constructor,
   /** @export */
   _embind_register_class_function: __embind_register_class_function,
   /** @export */
   _embind_register_emval: __embind_register_emval,
   /** @export */
+  _embind_register_enum: __embind_register_enum,
+  /** @export */
+  _embind_register_enum_value: __embind_register_enum_value,
+  /** @export */
   _embind_register_float: __embind_register_float,
   /** @export */
   _embind_register_function: __embind_register_function,
@@ -3685,6 +3815,8 @@ var wasmImports = {
   /** @export */
   _embind_register_memory_view: __embind_register_memory_view,
   /** @export */
+  _embind_register_optional: __embind_register_optional,
+  /** @export */
   _embind_register_smart_ptr: __embind_register_smart_ptr,
   /** @export */
   _embind_register_std_string: __embind_register_std_string,