GoJS Change Log

We maintain a GitHub Repository, which you can star to follow version updates. We also notify of changes on Twitter.

GoJS 2.3

New SVG Rendering Context

GoJS typically renders the Diagram to an HTML Canvas, and offers exporting the Diagram scene to image formats and SVG. In GoJS 2.3, the library now supports rendering to a live SVG context in addition to the default Canvas context. Visually there should be no changes, and performance will be faster when using the default Canvas context, but the SVG context may be useful for applications where DOM accessibility is paramount, either because users need to select and copy text, or because screen readers need access to all text in the application.

The new SVG rendering context comes with significant changes and upgrades to the GoJS SVG structure, including export SVG. For example, an object with a clip-path would formerly point to a <clippath> via URL, and now clipping paths are defined in-line. These changes make some elementFinished code in Diagram.makeSVG potentially incompatible.

Read more about the SVG Rendering Context here

New Layered Digraph Layout Options for Better Performance

Version 2.3 adds LayeredDigraphLayout.alignOption as a potentially faster alternative to LayeredDigraphLayout.packOption. When using this option, nodes are assigned coordinates within their layers to produce straighter paths of nodes and small edge lengths.

General New Features in GoJS 2.3

Changes for 2.3.1

GoJS 2.2

GoJS 2.2 introduces a number of properties and methods for convenience and to improve customization. GoJS 2.2 also includes new methods for constructing objects, and enhances TypeScript typings support.

GoJS 2.2 also includes several performance enhancements when drawing large graphs, reduced memory usage, and more efficient replacing or merging of item Arrays.

Some of the samples and written documentation have been upgraded to use more modern JavaScript: classes, arrow functions, const and let, so the samples and documentation might no longer be viewable using old browsers such as Internet Explorer 11 or some old Android browsers. The library and the extensions continue to target ES5 (ES2012), so that apps using the library can still work on IE11.

Method Chaining and New Ways to Build Objects

In GoJS 2.2 many methods that previously returned void now return the method's instance, to promote method chaining. GoJS 2.2 also introduces several new methods or arguments to allow type-checking of settings by compilers and in text editors.

Several existing methods now return their instance: GraphObject constructors now accept one or two optional arguments. The first is the value for a common property, and the second is a JavaScript Object detailing properties to initialize. For example, one can now write:

This means that one can now write code like:

// Create a Node and add a Shape and a TextBlock to it:
myDiagram.nodeTemplate =
  new go.Node("Vertical")
    .add(new go.Shape({ width: 40, height: 40, fill: "white" })  // default width & height & fill
          .bind("width") // binds data.width to Shape.width
          .bind("height")
          .bind("fill", "color") // binds data.color to Shape.fill
          .bind("figure", "fig")) // data.fig should be the registered name of a geometry figure generator
    .add(new go.TextBlock("(no name)",  // default string to display
                          { isMultiline: false, editable: true })
          .bind("text", "name", null, null));  // TwoWay Binding of TextBlock.text with data.name without converters

New methods GraphObject.set and Diagram.set return their instance. When using TypeScript definitions, the compiler checks these calls for GraphObject and Diagram property existence and value types.

New method GraphObject.apply can be used to define common functions that provide settings and bindings. Such customizations can then be applied to a GraphObject that you are initializing by calling GraphObject.apply with that function.

Together, these changes remove the need to use GraphObject,make when concisely defining Diagrams and templates. For a complete example, this code: 

const $ = go.GraphObject.make;

const myDiagram = $(go.Diagram, "myDiagramDiv",
  {
    "undoManager.isEnabled": true
  });

myDiagram.nodeTemplate =
  $(go.Node, "Auto",
    $(go.Shape, "RoundedRectangle",
      { strokeWidth: 0, fill: "white" },
      new go.Binding("fill", "color")),
    $(go.TextBlock,
      { margin: 8, font: "bold 14px sans-serif", stroke: '#333' },
      new go.Binding("text", "key"))
  );

Can now be written as:

const myDiagram = new go.Diagram("myDiagramDiv",
  {
    "undoManager.isEnabled": true
  });

myDiagram.nodeTemplate =
  new go.Node("Auto")
    .add(new go.Shape("RoundedRectangle", { strokeWidth: 0, fill: "white" })
          .bind("fill", "color"))
    .add(new go.TextBlock({ margin: 8, font: "bold 14px sans-serif", stroke: '#333' })
          .bind("text", "key"));

For more information and examples, see the intro page on Building Objects.

General New Features in GoJS 2.2

Easier Manipulation and Customization of Geometries

GoJS 2.2 contains new methods to simplify geometric calculations and more easily customize geometries.

Changes for 2.2.23

Changes for 2.2.22

Changes for 2.2.21

Changes for 2.2.20

Changes for 2.2.19

Changes for 2.2.18

Changes for 2.2.17

Changes for 2.2.16

Changes for 2.2.15

Changes for 2.2.14

Changes for 2.2.13

Changes for 2.2.12

Changes for 2.2.11

Changes for 2.2.10

Changes for 2.2.9

Changes for 2.2.8

Changes for 2.2.7

Changes for 2.2.6

Changes for 2.2.5

Changes for 2.2.4

Changes for 2.2.3

Changes for 2.2.2

Changes for 2.2.1

Changes for 2.1 are here.

Changes for 2.0 are here.

Changes for 1.* are here.

GoJS