Ej1 api migration in EJ2 TypeScript Treemap control

19 Apr 202324 minutes to read

This article describes the API migration process of Accordion component from Essential JS 1 to Essential JS 2.

Data Binding

Behavior API in Essential JS 1 API in Essential JS 2
Datasource Property: dataSource

var population_data = [{
  Continent: “Asia”,
  Population: 1749046000 }],
$(“#container”).ejTreeMap({
dataSource: population_data })		 Property: dataSource

var population_data = [{ Continent: “Asia”,
  Population: 1749046000 }],
let treemap: TreeMap = new TreeMap({
  dataSource: population_data
});
treemap.appendTo(‘#container’);

Appearance

Behavior API in Essential JS 1 API in Essential JS 2
Layout Property: itemsLayoutMode

$(“#container”).ejTreeMap({
itemsLayoutMode: “sliceanddiceauto” })		 Property: layoutType

let treemap: TreeMap = new TreeMap({
  layoutType: ‘SliceAndDiceAuto’
});
treemap.appendTo(‘#container’);
Weight Value Path Property: weightValuePath

$(“#container”).ejTreeMap({
weightValuePath: “Population” })		 Property: weightValuePath

let treemap: TreeMap = new TreeMap({
  weightValuePath: ‘Population’
});
treemap.appendTo(‘#container’);
Range Color Value Path Property: colorValuePath

$(“#container”).ejTreeMap({
colorValuePath: “Continent” })		 Property: rangeColorValuePath

let treemap: TreeMap = new TreeMap({
  rangeColorValuePath: ‘Continent’
});
treemap.appendTo(‘#container’);
Equal Color Value Path Not Applicable Property: equalColorValuePath

let treemap: TreeMap = new TreeMap({
  equalColorValuePath: ‘Asia’
});
treemap.appendTo(‘#container’);
Height Property: height

$(“#container”).ejTreeMap({
height: 50 })		 Property: height

let treemap: TreeMap = new TreeMap({
  height: ‘50px’
});
treemap.appendTo(‘#container’);
Width Property: width

$(“#container”).ejTreeMap({
width: 400 })		 Property: width

let treemap: TreeMap = new TreeMap({
  width: ‘400px’
});
treemap.appendTo(‘#container’);
Theme Not Applicable Property: theme

let treemap: TreeMap = new TreeMap({
  theme: ‘Highcontrast’
});
treemap.appendTo(‘#container’);
Localization Property: locale

$(“#container”).ejTreeMap({
locale: “en-US” })		 Property: locale

let treemap: TreeMap = new TreeMap({
  locale: ‘en-US’
});
treemap.appendTo(‘#container’);
Palette Colors Property: paletteColorMapping.colors

$(“#container”).ejTreeMap({
paletteColorMapping: { colors: [‘red’,’green’] } })		 Property: palette

let treemap: TreeMap = new TreeMap({
  palette: [‘#C33764’, ‘#AB3566’]
});
treemap.appendTo(‘#container’);
Margin Not Applicable Property: margin

let treemap: TreeMap = new TreeMap({
  margin: { left: 5, top: 8 }
});
treemap.appendTo(‘#container’);
Resize Property: enableResize

$(“#container”).ejTreeMap({
enableResize: true })		 Not Applicable
Responsive Property: isResponsive

$(“#container”).ejTreeMap({
isResponsive: true })		 Not Applicable

Leaf Items

Behavior API in Essential JS 1 API in Essential JS 2
Border Color Property: leafItemSettings.borderBrush

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  borderBrush: “blue” }
})		 Property: leafItemSettings.border

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { border: { color: ‘white’ } }
});
treemap.appendTo(‘#container’);
Border Width Property: leafItemSettings.borderThickness

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  borderThickness: 5 }
})		 Property: leafItemSettings.border

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { border: { width: 5 } }
});
treemap.appendTo(‘#container’);
Gap Value Property: leafItemSettings.gap

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  gap: 5 }
})		 Property: leafItemSettings.gap

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { gap: 5 }
});
treemap.appendTo(‘#container’);
Leaf Item Label Property: leafItemSettings.itemTemplate

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  itemTemplate: “template” }
})		 Property: leafItemSettings.labelTemplate

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { labelTemplate: ‘template’ }
});
treemap.appendTo(‘#container’);
Leaf Label Path Property: leafItemSettings.labelPath

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  labelPath: “GameName” }
})		 Property: leafItemSettings.labelPath

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { labelPath: ‘GameName’ }
});
treemap.appendTo(‘#container’);
Leaf Label Position Property: leafItemSettings.labelPosition

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true,
  labelPosition: “topcenter” }
})		 Property: leafItemSettings.labelPosition

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { labelPosition: ‘Center’ }
});
treemap.appendTo(‘#container’);
Leaf Label Color Not Applicable Property: leafItemSettings.fill

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { fill: ‘red’ }
});
treemap.appendTo(‘#container’);
Random Colors Not Applicable Property: leafItemSettings.autoFill

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { autoFill: true }
});
treemap.appendTo(‘#container’);
Format Not Applicable Property: leafItemSettings.labelFormat

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { labelFormat: ‘${Continent}-${Population}’ }
});
treemap.appendTo(‘#container’);
Labels Visibility Property: leafItemSettings.showLabels

$(“#container”).ejTreeMap({
  leafItemSettings: { showLabels: true }
})		 Property: leafItemSettings.showLabels

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { showLabels: false }
});
treemap.appendTo(‘#container’);
Opacity Not Applicable Property: *leafItemSettings.opacity *

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { opacity: 0.7 }
});
treemap.appendTo(‘#container’);
Padding Not Applicable Property: *leafItemSettings.padding *

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { padding: 5 }
});
treemap.appendTo(‘#container’);
Font Customization Not Applicable Property: leafItemSettings.labelStyle

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { labelStyle: { size: ‘12px’, color: ‘red’, opacity: 0.5 } }
});
treemap.appendTo(‘#container’);
Position of Template Not Applicable Property: leafItemSettings.templatePosition

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { templatePosition: ‘Center’ }
});
treemap.appendTo(‘#container’);

Legend

Behavior API in Essential JS 1 API in Essential JS 2
Legend Alignment Property: legendSettings.alignment

$(“#container”).ejTreeMap({
  legendSettings: { alignment: “far” }
})		 Property: legendSettings.alignment

let treemap: TreeMap = new TreeMap({
  legendSettings: { alignment: ‘Near’ }
});
treemap.appendTo(‘#container’);
Legend Visibility Property: showLegend

$(“#container”).ejTreeMap({
  showLegend: false
})		 Property: legendSettings.visible

let treemap: TreeMap = new TreeMap({
  legendSettings: { visible: true }
});
treemap.appendTo(‘#container’);
Legend Position Property: legendSettings.dockPosition

$(“#container”).ejTreeMap({
  legendSettings: { dockPosition: “bottom” }
})		 Property: legendSettings.position

let treemap: TreeMap = new TreeMap({
  legendSettings: { position: ‘Top’ }
});
treemap.appendTo(‘#container’);
Legend Height Property: legendSettings.height

$(“#container”).ejTreeMap({
  legendSettings: { height: 40 }
})		 Property: legendSettings.height

let treemap: TreeMap = new TreeMap({
  legendSettings: { height: ‘40px’ }
});
treemap.appendTo(‘#container’);
Legend Width Property: legendSettings.width

$(“#container”).ejTreeMap({
  legendSettings: { width: 100 }
})		 Property: legendSettings.width

let treemap: TreeMap = new TreeMap({
  legendSettings: { width: ‘100px’ }
});
treemap.appendTo(‘#container’);
Shape Height Property: legendSettings.iconHeight

$(“#container”).ejTreeMap({
  legendSettings: { iconHeight: 15 }
})		 Property: legendSettings.shapeHeight

let treemap: TreeMap = new TreeMap({
  legendSettings: { shapeHeight: ‘40px’ }
});
treemap.appendTo(‘#container’);
Shape Width Property: legendSettings.iconWidth

$(“#container”).ejTreeMap({
  legendSettings: { iconWidth: 8 }
})		 Property: legendSettings.shapeWidth

let treemap: TreeMap = new TreeMap({
  legendSettings: { shapeWidth: ‘40px’ }
});
treemap.appendTo(‘#container’);
Padding Not Applicable Property: legendSettings.shapePadding

let treemap: TreeMap = new TreeMap({
  legendSettings: { shapePadding: 10 }
});
treemap.appendTo(‘#container’);
Legend Title Property: legendSettings.title

$(“#container”).ejTreeMap({
  legendSettings: { title: “Population” }
})		 Property: legendSettings.title

let treemap: TreeMap = new TreeMap({
  legendSettings: { title: ‘Legend’ }
});
treemap.appendTo(‘#container’);
Legend Shape Not Applicable Property: legendSettings.shape

let treemap: TreeMap = new TreeMap({
  legendSettings: { shape: ‘Rectangle’ }
});
treemap.appendTo(‘#container’);
Legend Mode Property: legendSettings.mode

$(“#container”).ejTreeMap({
  legendSettings: { mode: “interactive” }
})		 Property: legendSettings.mode

let treemap: TreeMap = new TreeMap({
  legendSettings: { mode: ‘Interactive’ }
});
treemap.appendTo(‘#container’);
Legend Text Customization Not Applicable Property: legendSettings.textStyle

let treemap: TreeMap = new TreeMap({
  legendSettings: { textStyle: {
    size: ‘10px’, opacity: 0.5, color: ‘red’ } }
});
treemap.appendTo(‘#container’);
Legend Title Customization Not Applicable Property: legendSettings.titleStyle

let treemap: TreeMap = new TreeMap({
  legendSettings: { titleStyle: {
    size: ‘10px’, opacity: 0.5, color: ‘red’ } }
});
treemap.appendTo(‘#container’);
Legend Shape Border Not Applicable Property: legendSettings.shapeBorder

let treemap: TreeMap = new TreeMap({
  legendSettings: { shapeBorder: {
    width: 2, color: ‘red’ } }
});
treemap.appendTo(‘#container’);
Legend Template Property: legendSettings.template

$(“#container”).ejTreeMap({
  legendSettings: { template: “template” }
})		 Not Applicable
Left Label Property: legendSettings.leftLabel

$(“#container”).ejTreeMap({
  legendSettings: { mode: “interactive”, leftLabel: “10Million” }
})		 Not Applicable
Right Label Property: legendSettings.rightLabel

$(“#container”).ejTreeMap({
  legendSettings: { mode: “interactive”, rightLabel: “100Million” }
})		 Not Applicable
Legend Shape Image Not Applicable Property: legendSettings.imageUrl

let treemap: TreeMap = new TreeMap({
  legendSettings: { imageUrl: “image.png” }
});
treemap.appendTo(‘#container’);
Position in Intractive Legend Not Applicable Property: legendSettings.labelPosition

let treemap: TreeMap = new TreeMap({
  legendSettings: { labelPosition: “Center” }
});
treemap.appendTo(‘#container’);
Legend Location Not Applicable Property: legendSettings.location

let treemap: TreeMap = new TreeMap({
  legendSettings: { location: { x: 10, y: 20 } }
});
treemap.appendTo(‘#container’);
Legend Orientation Not Applicable Property: legendSettings.orientation

let treemap: TreeMap = new TreeMap({
  legendSettings: { orientation: “Horizontal” }
});
treemap.appendTo(‘#container’);

Levels

Behavior API in Essential JS 1 API in Essential JS 2
Random Colors Not Applicable Property: levels.autoFill

let treemap: TreeMap = new TreeMap({
  levels: [{ autoFill: true }]
});
treemap.appendTo(‘#container’);
Level Background Color Property: levels.groupBackground

$(“#container”).ejTreeMap({
  levels: [{ groupBackground: “white” }]
})		 Property: levels.fill

let treemap: TreeMap = new TreeMap({
  levels: [{ fill: ‘white’ }]
});
treemap.appendTo(‘#container’);
Level Border Color Property: levels.groupBorderColor

$(“#container”).ejTreeMap({
  levels: [{ groupBorderColor: “#58585B” }]
})		 Property: levels.border.color

let treemap: TreeMap = new TreeMap({
  levels: [{ border: { color: “#58585B” } }]
});
treemap.appendTo(‘#container’);
Level Border Width Property: levels.groupBorderThickness

$(“#container”).ejTreeMap({
  levels: [{ groupBorderThickness: 2 }]
})		 Property: levels.border.width

let treemap: TreeMap = new TreeMap({
  levels: [{ border: { width: 2 } }]
});
treemap.appendTo(‘#container’);
Group Gap Property: levels.groupGap

$(“#container”).ejTreeMap({
  levels: [{ groupGap: 2 }]
})		 Property: levels.groupGap

let treemap: TreeMap = new TreeMap({
  levels: [{ groupGap: 2 }]
});
treemap.appendTo(‘#container’);
Group Padding Property: levels.groupPadding

$(“#container”).ejTreeMap({
  levels: [{ groupPadding: 1 }]
})		 Property: levels.groupPadding

let treemap: TreeMap = new TreeMap({
  levels: [{ groupPadding: 1 }]
});
treemap.appendTo(‘#container’);
Group Path Property: levels.groupPath

$(“#container”).ejTreeMap({
  levels: [{ groupPath: “pathname” }]
})		 Property: levels.groupPath

let treemap: TreeMap = new TreeMap({
  levels: [{ groupPath: ‘pathname’ }]
});
treemap.appendTo(‘#container’);
Height of Header Level Property: levels.headerHeight

$(“#container”).ejTreeMap({
  levels: [{ headerHeight: 20 }]
})		 Property: levels.headerHeight

let treemap: TreeMap = new TreeMap({
  levels: [{ headerHeight: 20 }]
});
treemap.appendTo(‘#container’);
Header Template Property: levels.headerTemplate

$(“#container”).ejTreeMap({
  levels: [{ headerTemplate: “template” }]
})		 Property: levels.headerTemplate

let treemap: TreeMap = new TreeMap({
  levels: [{ headerTemplate: ‘template’ }]
});
treemap.appendTo(‘#container’);
Opacity of Color Not Applicable Property: levels.opacity

let treemap: TreeMap = new TreeMap({
  levels: [{ opacity: 0.5 }]
});
treemap.appendTo(‘#container’);
Header Visibility Property: levels.showHeader

$(“#container”).ejTreeMap({
  levels: [{ showHeader: false }]
})		 Property: levels.showHeader

let treemap: TreeMap = new TreeMap({
  levels: [{ showHeader: false }]
});
treemap.appendTo(‘#container’);
Template Position Property: levels.labelPosition

$(“#container”).ejTreeMap({
  levels: [{ labelPosition: “topleft” }]
})		 Property: levels.templatePosition

let treemap: TreeMap = new TreeMap({
  levels: [{ templatePosition: ‘Center’ }]
});
treemap.appendTo(‘#container’);
Header Style Not Applicable Property: levels.headerStyle

let treemap: TreeMap = new TreeMap({
  levels: [{ headerStyle: { color: ‘red’, size: ‘16px’, opacity: 0.7 } }]
});
treemap.appendTo(‘#container’);
Header Format Not Applicable Property: levels.headerFormat

let treemap: TreeMap = new TreeMap({
  levels: [{ headerFormat: ‘${Continent}’ }]
});
treemap.appendTo(‘#container’);
Header Alignment Not Applicable Property: levels.headerAlignment

let treemap: TreeMap = new TreeMap({
  levels: [{ headerAlignment: ‘Center’ }]
});
treemap.appendTo(‘#container’);

Selection

Behavior API in Essential JS 1 API in Essential JS 2
Selection Property: selectionMode

$(“#container”).ejTreeMap({
  selectionMode: “default”
})		 Property: selectionSettings.mode

let treemap: TreeMap = new TreeMap({
  selectionSettings: { enable: true, mode: ‘Item’ }
});
treemap.appendTo(‘#container’);
Selection Color Not Applicable Property: selectionSettings.fill

let treemap: TreeMap = new TreeMap({
  selectionSettings: { enable: true, fill: ‘blue’ }
});
treemap.appendTo(‘#container’);
Selection Color Opacity Not Applicable Property: selectionSettings.opacity

let treemap: TreeMap = new TreeMap({
  selectionSettings: { enable: true, fill: ‘blue’, opacity: 0.6 }
});
treemap.appendTo(‘#container’);
Border for selection Not Applicable Property: selectionSettings.border

let treemap: TreeMap = new TreeMap({
  selectionSettings: { border: { color: ‘red’, width: 2 } }
});
treemap.appendTo(‘#container’);

Hightlight

Behavior API in Essential JS 1 API in Essential JS 2
Highlight Group Selection Mode Property: highlightGroupOnSelection

$(“#container”).ejTreeMap({
  highlightGroupOnSelection: true
})		 Property: highlightSettings.mode

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘All’ }
});
treemap.appendTo(‘#container’);
Highlight Selection Mode Property: highlightOnSelection

$(“#container”).ejTreeMap({
  highlightOnSelection: true
})		 Property: highlightSettings.mode

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘Item’ }
});
treemap.appendTo(‘#container’);
Highlight Group Border Color Property: highlightGroupBorderBrush

$(“#container”).ejTreeMap({
  highlightGroupBorderBrush: ‘gray’
})		 Property: highlightSettings.border.color

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘All’,
    border: { color: ‘gray’ } }
});
treemap.appendTo(‘#container’);
Highlight Group Border Width Property: highlightGroupBorderThickness

$(“#container”).ejTreeMap({
  highlightGroupBorderThickness: 3
})		 Property: highlightSettings.border.width

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘All’,
    border: { width: 3 } }
});
treemap.appendTo(‘#container’);
Highlight Selection Border Color Property: highlightBorderBrush

$(“#container”).ejTreeMap({
  highlightBorderBrush: ‘gray’
})		 Property: highlightSettings.border.color

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘Item’,
    border: { color: ‘gray’ } }
});
treemap.appendTo(‘#container’);
Highlight Selection Border Width Property: highlightBorderThickness

$(“#container”).ejTreeMap({
  highlightBorderThickness: 3
})		 Property: highlightSettings.border.width

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, mode: ‘Item’,
    border: { width: 3 } }
});
treemap.appendTo(‘#container’);
Highlight Color Not Applicable Property: highlightSettings.fill

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, fill: ‘red’ }
});
treemap.appendTo(‘#container’);
Highlight Color Opacity Not Applicable Property: highlightSettings.opacity

let treemap: TreeMap = new TreeMap({
  highlightSettings: { enable: true, fill: ‘red’, opacity: 0.5 }
});
treemap.appendTo(‘#container’);

Range ColorMapping

Behavior API in Essential JS 1 API in Essential JS 2
From value Property: rangeColorMapping.from

$(“#container”).ejTreeMap({
  rangeColorMapping: [{ from: 1000 }]
})		 Property: leafItemSettings.colorMapping.from

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ from: 1000 }] }
});
treemap.appendTo(‘#container’);
To value Property: rangeColorMapping.to

$(“#container”).ejTreeMap({
  rangeColorMapping: [{ to: 100000 }]
})		 Property: leafItemSettings.colorMapping.to

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ to: 100000 }] }
});
treemap.appendTo(‘#container’);
Color Property: rangeColorMapping.color

$(“#container”).ejTreeMap({
  rangeColorMapping: [{ color: “#77D8D8” }]
})		 Property: leafItemSettings.colorMapping.color

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ color: “#77D8D8” }] }
});
treemap.appendTo(‘#container’);
Legend Label Property: rangeColorMapping.legendLabel

$(“#container”).ejTreeMap({
  rangeColorMapping: [{ legendLabel: “Growth” }]
})		 Property: leafItemSettings.colorMapping.label

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ label: “Growth” }] }
});
treemap.appendTo(‘#container’);

Desaturation ColorMapping

Behavior API in Essential JS 1 API in Essential JS 2
From value Property: desaturationColorMapping.from

$(“#container”).ejTreeMap({
  desaturationColorMapping: [{ from: 1000 }]
})		 Property: leafItemSettings.colorMapping.from

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ from: 1000 }] }
});
treemap.appendTo(‘#container’);
To value Property: desaturationColorMapping.to

$(“#container”).ejTreeMap({
  desaturationColorMapping: [{ to: 10000 }]
})		 Property: leafItemSettings.colorMapping.to

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ to: 10000 }] }
});
treemap.appendTo(‘#container’);
Color Property: desaturationColorMapping.color

$(“#container”).ejTreeMap({
  desaturationColorMapping: [{ color: “#77D8D8” }]
})		 Property: leafItemSettings.colorMapping.color

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ color: “#77D8D8” }] }
});
treemap.appendTo(‘#container’);
Value Not Applicable Property: leafItemSettings.colorMapping.value

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ value: “Population” }] }
});
treemap.appendTo(‘#container’);
Minimum Opacity Not Applicable Property: leafItemSettings.colorMapping.minOpacity

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ minOpacity: 0.7 }] }
});
treemap.appendTo(‘#container’);
Maximum Opacity Not Applicable Property: leafItemSettings.colorMapping.maxOpacity

let treemap: TreeMap = new TreeMap({
  leafItemSettings: { colorMapping: [{ maxOpacity: 1 }] }
});
treemap.appendTo(‘#container’);

Tooltip

Behavior API in Essential JS 1 API in Essential JS 2
Tooltip Property: showTooltip

$(“#container”).ejTreeMap({
  showTooltip: true
})		 Property: tooltipSettings.visible

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { visible: true }
});
treemap.appendTo(‘#container’);
Tooltip Template Property: tooltipTemplate

$(“#container”).ejTreeMap({
  tooltipTemplate: ‘template’
})		 Property: tooltipSettings.template

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { template: ‘template’ }
});
treemap.appendTo(‘#container’);
Tooltip Border Not Applicable Property: tooltipSettings.border

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { border: { color: ‘red’, width: 2 } }
});
treemap.appendTo(‘#container’);
Tooltip Color Not Applicable Property: tooltipSettings.fill

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { fill: ‘gray’ }
});
treemap.appendTo(‘#container’);
Tooltip Format Not Applicable Property: tooltipSettings.format

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { format: ‘${Population}’ }
});
treemap.appendTo(‘#container’);
Tooltip Marker Shape Not Applicable Property: tooltipSettings.markerShapes

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { markerShapes: ‘Circle’ }
});
treemap.appendTo(‘#container’);
Tooltip Color Opacity Not Applicable Property: tooltipSettings.opacity

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { opacity: 0.5 }
});
treemap.appendTo(‘#container’);
Tooltip Text Style Not Applicable Property: tooltipSettings.textStyle

let treemap: TreeMap = new TreeMap({
  tooltipSettings: { textStyle: {
    Color: ‘red’, opacity: 0.5, size: ‘12px’ } }
});
treemap.appendTo(‘#container’);

Drilldown

Behavior API in Essential JS 1 API in Essential JS 2
Drilldown Property: enableDrillDown

$(“#container”).ejTreeMap({
  enableDrillDown: true
})		 Property: enableDrillDown

let treemap: TreeMap = new TreeMap({
  enableDrillDown: true
});
treemap.appendTo(‘#container’);
Drilldown Level Property: drillDownLevel

$(“#container”).ejTreeMap({
  drillDownLevel: 1
})		 Property: InitialDrillSettings.groupIndex

let treemap: TreeMap = new TreeMap({
  InitialDrillSettings: { groupIndex: 1 }
});
treemap.appendTo(‘#container’);

Methods

Behavior API in Essential JS 1 API in Essential JS 2
Treemap Refresh Method Method: refresh

$(“#container”).ejTreeMap({ “refresh” })		 Method: refresh

let treemap: TreeMap = new TreeMap({
  treemap.refresh(); });
treemap.appendTo(‘#container’);
Method to Drilldown Method: drillDown

$(“#container”).ejTreeMap({ “drillDown” })		 Not Applicable
Append to Method Not Applicable Method: appendTo

let treemap: TreeMap = new TreeMap({
});
treemap.appendTo(‘#container’);
Add Event Listener Method Not Applicable Method: addEventListener

let treemap: TreeMap = new TreeMap({
  treemap.addEventListener();
});
treemap.appendTo(‘#container’);
Treemap Destroy Method Not Applicable Method: destroy

let treemap: TreeMap = new TreeMap({
  treemap.destroy();
});
treemap.appendTo(‘#container’);
Treemap Exporting Method Not Applicable Method: export

let treemap: TreeMap = new TreeMap({
  treemap.export(‘png’,’treemap’);
});
treemap.appendTo(‘#container’);
Get the Module Name Not Applicable Method: getModuleName

let treemap: TreeMap = new TreeMap({
  this.getModuleName();
});
treemap.appendTo(‘#container’);
Printing the Treemap Not Applicable Method: print

let treemap: TreeMap = new TreeMap({
  treemap.print();
});
treemap.appendTo(‘#container’);
Resizing the Treemap Not Applicable Method: resizeOnTreeMap

let treemap: TreeMap = new TreeMap({
  treemap.resizeOnTreeMap();
});
treemap.appendTo(‘#container’);
Inject Method (Tooltip) Not Applicable Method: resizeOnTreeMap

TreeMap.Inject(TreeMapTooltip);
let treemap: TreeMap = new TreeMap({ });
treemap.appendTo(‘#container’);
Remove Event Listener Method Not Applicable Method: removeEventListener

let treemap: TreeMap = new TreeMap({
  treemap.removeEventListener();
});
treemap.appendTo(‘#container’);

Events

Behavior API in Essential JS 1 API in Essential JS 2
Treemap Load Event Not Applicable Event: load

let treemap: TreeMap = new TreeMap({
  load: function(e: ILoadEventArgs): void { }
});
treemap.appendTo(‘#container’);
Treemap Loaded Event Not Applicable Event: loaded

let treemap: TreeMap = new TreeMap({
  loaded: function(e: ILoadedEventArgs): void { }
});
treemap.appendTo(‘#container’);
Event Before Print Not Applicable Event: beforePrint

let treemap: TreeMap = new TreeMap({
  beforePrint: function(e: IPrintEventArgs): void { }
});
treemap.appendTo(‘#container’);
Click Event Event: click

$(“#container”).ejTreeMap({
  click: function (args) { }
})		 Event: click

let treemap: TreeMap = new TreeMap({
  click: function(e: IItemClickEventArgs): void { }
});
treemap.appendTo(‘#container’);
Drill Start Event Event: drillStarted

$(“#container”).ejTreeMap({
  drillStarted: function (args) { }
})		 Event: drillStart

let treemap: TreeMap = new TreeMap({
  drillStart: function(e: IDrillStartEventArgs): void { }
});
treemap.appendTo(‘#container’);
Drill End Event Not Applicable Event: drillEnd

let treemap: TreeMap = new TreeMap({
  drillEnd: function(e: IDrillEndEventArgs): void { }
});
treemap.appendTo(‘#container’);
Event on Item Click Not Applicable Event: itemClick

let treemap: TreeMap = new TreeMap({
  itemClick: function(e: IItemClickEventArgs): void { }
});
treemap.appendTo(‘#container’);
Treemap Item Select Event Event: treeMapItemSelected

$(“#container”).ejTreeMap({
  treeMapItemSelected: function (args) { }
})		 Event: itemSelected

let treemap: TreeMap = new TreeMap({
  itemSelected: function(e: IItemSelectedEventArgs): void { }
});
treemap.appendTo(‘#container’);
Treemap Item Rendering Event Event: itemRendering

$(“#container”).ejTreeMap({
  itemRendering: function (args) { }
})		 Event: itemRendering

let treemap: TreeMap = new TreeMap({
  itemRendering: function(e: IItemRenderingEventArgs): void { }
});
treemap.appendTo(‘#container’);
Treemap Item Move Event Not Applicable Event: itemMove

let treemap: TreeMap = new TreeMap({
  itemMove: function(e: IItemMoveEventArgs): void { }
});
treemap.appendTo(‘#container’);
Treemap Item Highlight Event Not Applicable Event: itemHighlight

let treemap: TreeMap = new TreeMap({
  itemHighlight: function(e: IItemHighlightEventArgs): void { }
});
treemap.appendTo(‘#container’);
Template Header Render Event Event: headerTemplateRendering

$(“#container”).ejTreeMap({
  headerTemplateRendering: function (args) { }
})		 Not Applicable
Drilldown Item Select Event Event: drillDownItemSelected

$(“#container”).ejTreeMap({
  drillDownItemSelected: function (args) { }
})		 Not Applicable
Refresh Event Event: refreshed

$(“#container”).ejTreeMap({
  refreshed: function (args) { }
})		 Not Applicable
Group Select Event Event: treeMapGroupSelected

$(“#container”).ejTreeMap({
  treeMapGroupSelected: function (args) { }
})		 Not Applicable
Mouse Event Not Applicable Event: mouseMove

let treemap: TreeMap = new TreeMap({
  mouseMove: function(e: IMouseMoveEventArgs): void { }
});
treemap.appendTo(‘#container’);
Resize Event Not Applicable Event: resize

let treemap: TreeMap = new TreeMap({
  resize: function(e: IResizeEventArgs): void { }
});
treemap.appendTo(‘#container’);
Tooltip Render Event Not Applicable Event: tooltipRendering

let treemap: TreeMap = new TreeMap({
  tooltipRendering: function(e: ITreeMapTooltipRenderEventArgs): void { }
});
treemap.appendTo(‘#container’);
Double Click Event Event: doubleClick

$(“#container”).ejTreeMap({
  doubleClick: function (args) { }
})		 Not Applicable
Right Click Event Event: rightClick

$(“#container”).ejTreeMap({
  rightClick: function (args) { }
})		 Not Applicable