jpf 5.0.62 → 5.0.64

package/src/controls/custom/ListItem/ListItem.ts

@@ -1,14 +1,12 @@
-import { Element, getElement, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties } from "../../../framework/properties";
-import { isSubscribable, unwrap } from "../../../framework/observablelmplementations";
-import { ISubscribable } from "../../../framework/observableInterfaces";
+import { Element,ElementProperties, IElementProperties, extendProperties, getElement, addElementToDictionary } from "../../../framework/element";
+import { ISubscribable , observable} from "../../../framework/observable";
 
 //Do not change property names since they have to correspond to kendo listItems
 //so this type can be used in kendo list controls like menu and tree
 
-export interface IListItemProperties extends IProperties {
+export interface IListItemProperties extends IElementProperties {
     id: number | string;
-    text?: string | ISubscribable<string> | Properties;
+    text?: string | ISubscribable<string> | ElementProperties;
     select?: () => void;
     order?: number | string;
 }
@@ -39,8 +37,8 @@ export class ListItemElement extends Element<IListItemProperties> {
 
         const properties = this.properties;
 
-        if (isSubscribable(properties.text)) {
-            this.setContent(unwrap(properties.text));
+        if (observable.isSubscribable(properties.text)) {
+            this.setContent(observable.unwrap(properties.text));
             this.disposers.push(
                 properties.text.subscribe((text) => {
                     this.setContent(text);
@@ -51,10 +49,10 @@ export class ListItemElement extends Element<IListItemProperties> {
         }
     }
 
-    private setContent(content: string | Properties) {
+    private setContent(content: string | ElementProperties) {
         if (typeof content === "string") {
-            this.element.innerHTML = content;
-        } else if (content instanceof Properties) {
+            this.htmlElement.innerHTML = content;
+        } else if (content instanceof ElementProperties) {
             this.setChildren(getElement(content));
         }
     }
@@ -64,13 +62,13 @@ export function createListItem(properties: IListItemProperties) {
     return new ListItemElement(properties);
 }
 
-export class ListItemProperties extends Properties implements IListItemProperties {
+export class ListItemProperties extends ElementProperties implements IListItemProperties {
     constructor(properties: IListItemProperties) {
         super();
         this.setProperties(this, properties);
     }
     id: number | string;
-    text?: string | Properties;
+    text?: string | ElementProperties;
     select?: () => void;
     order?: number | string;
 }
@@ -80,13 +78,13 @@ addElementToDictionary(
     ListItemElement
 );
 
-export class HierarchicalListItemProperties extends Properties implements IHierarchicalListItemProperties {
+export class HierarchicalListItemProperties extends ElementProperties implements IHierarchicalListItemProperties {
     constructor(properties: IHierarchicalListItemProperties) {
         super();
         this.setProperties(this, properties);
     }
     id: number | string;
-    text?: string | Properties;
+    text?: string | ElementProperties;
     select?: () => void;
     order?: number | string;
     parentId?: number | string;

package/src/controls/html/Button/Button.ts

@@ -1,10 +1,8 @@
-import { Properties, IProperties, extendProperties } from "../../../framework/properties"
-import { Element, getElement, addElementToDictionary } from "../../../framework/element";
-import { ISubscribable } from "../../../framework/observableInterfaces";
-import { isSubscribable, unwrap } from "../../../framework/observablelmplementations";
+import { Element, getElement, addElementToDictionary,ElementProperties, IElementProperties, extendProperties  } from "../../../framework/element";
+import { ISubscribable, observable } from "../../../framework/observable";
 
-export interface IButtonProperties extends IProperties {
-    content?: string | Properties | ISubscribable<string | Properties>;
+export interface IButtonProperties extends IElementProperties {
+    content?: string | ElementProperties | ISubscribable<string | ElementProperties>;
 }
 
 export class ButtonElement extends Element<IButtonProperties> {
@@ -27,9 +25,9 @@ export class ButtonElement extends Element<IButtonProperties> {
 
         const properties = this.properties;
         if (properties.content) {
-            this.buildContent(unwrap(properties.content));
+            this.buildContent(observable.unwrap(properties.content));
 
-            if (isSubscribable(properties.content)) {
+            if (observable.isSubscribable(properties.content)) {
                 this.disposers.push(
                     properties.content.subscribe((content) => {
                         this.buildContent(content);
@@ -39,15 +37,15 @@ export class ButtonElement extends Element<IButtonProperties> {
         }
     }
 
-    private buildContent(content: string | Properties) {
+    private buildContent(content: string | ElementProperties) {
         if (content == null || content === undefined) {
-            this.element.innerText = null;
+            this.htmlElement.innerText = null;
         }
         else if (typeof content === "string") {
-            this.element.innerText = content;
+            this.htmlElement.innerText = content;
         }
-        else if (content instanceof Properties) {
-            this.setChildren(getElement(content as Properties));
+        else if (content instanceof ElementProperties) {
+            this.setChildren(getElement(content as ElementProperties));
         }
     }
 }
@@ -56,12 +54,12 @@ export function createButton(properties: IButtonProperties) {
     return new ButtonElement(properties);
 }
 
-export class ButtonProperties extends Properties implements IButtonProperties {
+export class ButtonProperties extends ElementProperties implements IButtonProperties {
     constructor(properties: IButtonProperties) {
         super();
         this.setProperties(this, properties);
     }
-    content?: string | Properties | ISubscribable<string | Properties>;
+    content?: string | ElementProperties | ISubscribable<string | ElementProperties>;
 }
 
 addElementToDictionary(

package/src/controls/html/Div/Div.ts

@@ -1,8 +1,7 @@
-import { Element, IElement, addElementToDictionary } from "../../../framework/element";
-import { IProperties, extendProperties, Properties } from "../../../framework/properties";
-import { ISubscribable } from "../../../framework/observableInterfaces";
+import { Element, ElementProperties, IElement, IElementProperties, extendProperties, addElementToDictionary } from "../../../framework/element";
+import { ISubscribable } from "../../../framework/observable";
 
-export interface IDivProperties extends IProperties {
+export interface IDivProperties extends IElementProperties {
     children?: Array<IElement> | ISubscribable<Array<IElement>>;
 }
 export class DivElement extends Element<IDivProperties> {
@@ -26,7 +25,7 @@ export function createDiv(properties: IDivProperties) {
     return new DivElement(properties);
 }
 
-export class DivProperties extends Properties implements IDivProperties {
+export class DivProperties extends ElementProperties implements IDivProperties {
     constructor(properties: IDivProperties) {
         super();
         this.setProperties(this, properties);

package/src/controls/html/Image/Image.ts

@@ -1,8 +1,7 @@
-import { Element, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties } from "../../../framework/properties";
-import { ISubscribable } from "../../../framework/observableInterfaces";
+import { Element, addElementToDictionary,ElementProperties, IElementProperties, extendProperties  } from "../../../framework/element";
+import { ISubscribable } from "../../../framework/observable";
 
-export interface IImageProperties extends IProperties {
+export interface IImageProperties extends IElementProperties {
     src: string | ISubscribable<string>;
     alt: string | ISubscribable<string>;
 }
@@ -33,7 +32,7 @@ export function createImage(properties: IImageProperties) {
     return new ImageElement(properties);
 }
 
-export class ImageProperties extends Properties implements IImageProperties {
+export class ImageProperties extends ElementProperties implements IImageProperties {
     constructor(properties: IImageProperties) {
         super();
         this.setProperties(this, properties);

package/src/controls/html/Input/Input.ts

@@ -1,9 +1,8 @@
-import { Element, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties, isNullOrUndefined } from "../../../framework/properties";
+import { Element, addElementToDictionary, ElementProperties, IElementProperties, extendProperties } from "../../../framework/element";
 import { isInteger } from "../../../utilities/integer/integer";
 import { isFloat } from "../../../utilities/float/float";
-import { ISubscribable } from "../../../framework/observableInterfaces";
-import { isSubscribable, unwrap, isObservableValue } from "../../../framework/observablelmplementations";
+import { ISubscribable, observable } from "../../../framework/observable";
+import{isNullOrUndefined} from "../../../utilities/value/value";
 
 
 export type InputType = "text" | "checkbox" | "file" | "integer" | "float" | "range" | "radio";
@@ -13,7 +12,7 @@ export enum ValueUpdateModeEnum {
     OnInput = 2
 }
 
-export interface IInputProperties<TValue> extends IProperties {
+export interface IInputProperties<TValue> extends IElementProperties {
     value?: TValue | ISubscribable<TValue>;
     inputValidator?: (event: Event, inputViewModel: IInputProperties<TValue>, value: string) => Promise<boolean>;
     placeholder?: string | ISubscribable<string>;
@@ -43,13 +42,13 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
     protected build() {
         super.build();
 
-        const element = this.element;
+        const element = this.htmlElement;
         const properties = this.properties;
         if (!properties.valueUpdateMode) {
             properties.valueUpdateMode = ValueUpdateModeEnum.OnChange;
         }
 
-        const input = this.element as HTMLInputElement;
+        const input = this.htmlElement as HTMLInputElement;
         input.type = properties.type;
 
         if (!isNullOrUndefined(properties.min)) {
@@ -64,8 +63,8 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
 
         switch (properties.type) {
             case "checkbox":
-                input.checked = unwrap(properties.value) as unknown as boolean;
-                if (isSubscribable(properties.value)) {
+                input.checked = observable.unwrap(properties.value) as unknown as boolean;
+                if (observable.isSubscribable(properties.value)) {
                     this.disposers.push(
                         properties.value.subscribe((value) => {
                             input.checked = value as unknown as boolean;
@@ -80,8 +79,8 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
                 break;
 
             case "radio":
-                input.checked = input.value === ((unwrap(properties.value)) as unknown as string);
-                if (isSubscribable(properties.value)) {
+                input.checked = input.value === ((observable.unwrap(properties.value)) as unknown as string);
+                if (observable.isSubscribable(properties.value)) {
                     this.disposers.push(
                         properties.value.subscribe((value) => {
                             input.checked = input.value === (value as unknown as string);
@@ -91,11 +90,11 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
                 break;
 
             default:
-                const value = unwrap(properties.value);
+                const value = observable.unwrap(properties.value);
                 if (value) {
                     input.value = value as unknown as string;
                 }
-                if (isSubscribable(properties.value)) {
+                if (observable.isSubscribable(properties.value)) {
                     this.disposers.push(
                         properties.value.subscribe((value) => {
                             input.value = value as unknown as string;
@@ -104,11 +103,11 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
                 }
         }
 
-        const placeholder = unwrap(properties.placeholder) as unknown as string;
+        const placeholder = observable.unwrap(properties.placeholder) as unknown as string;
         if (placeholder) {
             input.placeholder = placeholder;
         }
-        if (isSubscribable(properties.placeholder)) {
+        if (observable.isSubscribable(properties.placeholder)) {
             this.disposers.push(
                 properties.placeholder.subscribe((placeholder) => {
                     if (placeholder) {
@@ -121,14 +120,14 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
         }
 
         if (this.properties.valueUpdateMode === ValueUpdateModeEnum.OnChange) {
-            this.element.addEventListener(
+            this.htmlElement.addEventListener(
                 "change",
                 handleEvent
             );
         }
 
         if (this.properties.valueUpdateMode === ValueUpdateModeEnum.OnInput || properties.inputValidator) {
-            this.element.addEventListener(
+            this.htmlElement.addEventListener(
                 "input",
                 handleEvent
             );
@@ -164,7 +163,7 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
 
             if (properties.inputValidator) {
                 if (!await properties.inputValidator(event, properties, newValue as unknown as string)) {
-                    input.value = unwrap(properties.value) as unknown as string;
+                    input.value = observable.unwrap(properties.value) as unknown as string;
                     return;
                 };
             }
@@ -173,7 +172,7 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
                 if (isInteger(newValue)) {
                     newValue = parseInt(newValue);
                 } else {
-                    input.value = unwrap(properties.value) as unknown as string;
+                    input.value = observable.unwrap(properties.value) as unknown as string;
                     return;
                 }
             }
@@ -182,13 +181,13 @@ export class InputElement<TValue> extends Element<IInputProperties<TValue>> {
                 if (isFloat(newValue)) {
                     newValue = parseFloat(newValue);
                 } else {
-                    input.value = unwrap(properties.value) as unknown as string;
+                    input.value = observable.unwrap(properties.value) as unknown as string;
                     return;
                 }
             }
 
             //if validation has succeeded we set the viewModel value
-            if (isObservableValue(properties.value)) {
+            if (observable.isObservableValue(properties.value)) {
                 if ((event.type === "change" && properties.valueUpdateMode === ValueUpdateModeEnum.OnChange) ||
                     (event.type === "input" && properties.valueUpdateMode === ValueUpdateModeEnum.OnInput)) {
 
@@ -205,7 +204,7 @@ export function createInput<TValue>(properties: IInputProperties<TValue>) {
     return new InputElement<TValue>(properties);
 }
 
-export class InputProperties<TValue> extends Properties implements IInputProperties<TValue> {
+export class InputProperties<TValue> extends ElementProperties implements IInputProperties<TValue> {
     constructor(properties: IInputProperties<TValue>) {
         super();
         this.setProperties(this, properties);

package/src/controls/html/Select/Select.ts

@@ -1,9 +1,7 @@
-import { Element, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties } from "../../../framework/properties";
-import { ISubscribable } from "../../../framework/observableInterfaces";
-import { isSubscribable, unwrap , isObservableValue} from "../../../framework/observablelmplementations";
+import { Element, addElementToDictionary, ElementProperties, IElementProperties, extendProperties } from "../../../framework/element";
+import { ISubscribable, observable } from "../../../framework/observable";
 
-export interface ISelectProperties<TItem, TValue, TSetter = TValue> extends IProperties {
+export interface ISelectProperties<TItem, TValue, TSetter = TValue> extends IElementProperties {
     value?: TValue | ISubscribable<TValue>;
     items?: Array<TItem> | ISubscribable<Array<TItem>>;
     textFunction: (item: TItem) => string;
@@ -30,12 +28,12 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
     //Protected members
     protected build() {
         super.build();
-        const select = this.element as HTMLSelectElement;
+        const select = this.htmlElement as HTMLSelectElement;
 
         const properties = this.properties;
 
-        this.setItems(unwrap(properties.items) as Array<TItem>);
-        if (isSubscribable(properties.items)) {
+        this.setItems(observable.unwrap(properties.items) as Array<TItem>);
+        if (observable.isSubscribable(properties.items)) {
             this.disposers.push(
                 properties.items.subscribe((items) => {
                     this.setItems(items);
@@ -43,8 +41,8 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
             );
         }
 
-        this.setSelectedValue(unwrap(properties.value) as TValue);
-        if (isSubscribable(properties.value)) {
+        this.setSelectedValue(observable.unwrap(properties.value) as TValue);
+        if (observable.isSubscribable(properties.value)) {
             this.disposers.push(
                 properties.value.subscribe((value) => {
                     this.setSelectedValue(value);
@@ -52,7 +50,7 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
             );
         }
 
-        this.element.addEventListener(
+        this.htmlElement.addEventListener(
             "change",
             async (event: Event) => {
                 let selectedValue = select.value as unknown as TValue;
@@ -65,12 +63,12 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
                 }
                 if (properties.inputValidator) {
                     if (!await properties.inputValidator(event, properties, selectedValue)) {
-                        select.value = unwrap(properties.value) as unknown as string;
+                        select.value = observable.unwrap(properties.value) as unknown as string;
                         return;
                     };
                 }
 
-                if (isObservableValue(properties.value)) {
+                if (observable.isObservableValue(properties.value)) {
                     if (properties.setFunction) {
                         const setValue = properties.setFunction(selectedItem) as unknown as TValue;
                         properties.value.setValueInAction(setValue);
@@ -85,10 +83,10 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
     private itemDictionary: { [key: string]: TItem };
 
     private setItems(items: Array<TItem>) {
-        if (this.element) {
+        if (this.htmlElement) {
             this.itemDictionary = {};
             if (items) {
-                const select = this.element as HTMLSelectElement;
+                const select = this.htmlElement as HTMLSelectElement;
                 select.innerHTML = null;
                 if (this.properties.emptyItemText) {
                     const emptyOption = document.createElement("option") as HTMLOptionElement;
@@ -110,8 +108,8 @@ export class SelectElement<TItem, TValue, TSetter = TValue> extends Element<ISel
     }
 
     private setSelectedValue(value: TValue) {
-        if (this.element) {
-            const select = this.element as HTMLSelectElement;
+        if (this.htmlElement) {
+            const select = this.htmlElement as HTMLSelectElement;
             if (value === null || value === undefined) {
                 select.value = "";
             } else {
@@ -125,7 +123,7 @@ export function createSelect<TItem, TValue, TSetter = TValue>(properties: ISelec
     return new SelectElement(properties);
 }
 
-export class SelectProperties<TItem, TValue, TSetter = TValue> extends Properties implements ISelectProperties<TItem, TValue, TSetter> {
+export class SelectProperties<TItem, TValue, TSetter = TValue> extends ElementProperties implements ISelectProperties<TItem, TValue, TSetter> {
     constructor(properties: ISelectProperties<TItem, TValue, TSetter>) {
         super();
         this.setProperties(this, properties);

package/src/controls/html/Span/Span.ts

@@ -1,8 +1,7 @@
-import { Element, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties } from "../../../framework/properties";
+import { Element, addElementToDictionary,ElementProperties, IElementProperties, extendProperties  } from "../../../framework/element";
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface ISpanProperties extends IProperties {
+export interface ISpanProperties extends IElementProperties {
 
 }
 
@@ -26,7 +25,7 @@ export function createSpan(properties: ISpanProperties) {
     return new SpanElement(properties);
 }
 
-export class SpanProperties extends Properties implements ISpanProperties {
+export class SpanProperties extends ElementProperties implements ISpanProperties {
     constructor(properties: SpanProperties) {
         super();
         this.setProperties(this, properties);

package/src/controls/jsonViewerAwesome/jsonFormatter/JsonFormatter.ts

@@ -1,10 +1,8 @@
-import { Element, addElementToDictionary } from "../../../framework/element";
-import { Properties, IProperties, extendProperties } from "../../../framework/properties";
+import { Element, ElementProperties, IElementProperties, extendProperties, addElementToDictionary } from "../../../framework/element";
 import { JSONFormatter } from "json-viewer-awesome/lib/json-formatter";
-import { ISubscribable } from "../../../framework/observableInterfaces";
-import { isSubscribable, unwrap } from "../../../framework/observablelmplementations";
+import { ISubscribable, observable } from "../../../framework/observable";
 
-export interface IJsonFormatterProperties extends IProperties {
+export interface IJsonFormatterProperties extends IElementProperties {
     json: object | ISubscribable<object>;
     showArrayIndex?: boolean;
     quotesOnKeys?: boolean;
@@ -33,11 +31,11 @@ export class JsonFormatterElement extends Element<IJsonFormatterProperties> {
         super.build();
 
         const properties = this.properties;
-        this.setJson(unwrap(properties.json));
-        if (isSubscribable(properties.json)) {
+        this.setJson(observable.unwrap(properties.json));
+        if (observable.isSubscribable(properties.json)) {
             this.disposers.push(
-                properties.json.subscribe((json)=>{
-                      this.setJson(json as unknown as object);
+                properties.json.subscribe((json) => {
+                    this.setJson(json as unknown as object);
                 })
             );
         }
@@ -58,9 +56,9 @@ export class JsonFormatterElement extends Element<IJsonFormatterProperties> {
                     src: json
                 });
 
-                this.element.replaceChildren(jsonFormatter.render());
+                this.htmlElement.replaceChildren(jsonFormatter.render());
             } else {
-                this.element.innerHTML = (json as unknown).toString();
+                this.htmlElement.innerHTML = (json as unknown).toString();
             }
         } else {
             this.empty();
@@ -72,7 +70,7 @@ export function createJsonFormatter(properties: IJsonFormatterProperties) {
     return new JsonFormatterElement(properties);
 }
 
-export class JsonFormatterProperties extends Properties implements IJsonFormatterProperties {
+export class JsonFormatterProperties extends ElementProperties implements IJsonFormatterProperties {
     constructor(properties: IJsonFormatterProperties) {
         super();
         this.setProperties(this, properties);

package/src/controls/kendo/Chart/Chart.ts

@@ -1,10 +1,8 @@
 import * as kendo from "@progress/kendo-ui/js/kendo.dataviz.chart";
-import { Element } from "../../../framework/element";
-import { IProperties, extendProperties } from "../../../framework/properties";
-import { ISubscribable } from "../../../framework/observableInterfaces";
-import { isSubscribable, unwrap } from "../../../framework/observablelmplementations";
+import { Element, IElementProperties, extendProperties } from "../../../framework/element";
+import { ISubscribable, observable } from "../../../framework/observable";
 
-export interface IChartProperties extends IProperties {
+export interface IChartProperties extends IElementProperties {
     data?: Array<unknown> | ISubscribable<Array<unknown>>;
     chartArea?: kendo.dataviz.ui.ChartChartArea | undefined;
     series?: kendo.dataviz.ui.ChartSeriesItem[] | ISubscribable<kendo.dataviz.ui.ChartSeriesItem[]>;
@@ -13,7 +11,7 @@ export interface IChartProperties extends IProperties {
     legend?: kendo.dataviz.ui.ChartLegend | undefined;
 }
 
-export class ChartElement extends Element<IChartProperties>{
+export class ChartElement extends Element<IChartProperties> {
     constructor(properties: IChartProperties) {
         super(
             {
@@ -39,12 +37,12 @@ export class ChartElement extends Element<IChartProperties>{
         if (properties.data) {
             this.dataSource = new kendo.data.DataSource(
                 {
-                    data: unwrap(properties.data)
+                    data: observable.unwrap(properties.data)
                 }
             );
         }
 
-        if (isSubscribable(properties.data)) {
+        if (observable.isSubscribable(properties.data)) {
             this.disposers.push(
                 properties.data.subscribe((data) => {
                     this.dataSource.data(data);
@@ -54,20 +52,20 @@ export class ChartElement extends Element<IChartProperties>{
 
         setTimeout(() => {
             this.chart = new kendo.dataviz.ui.Chart(
-                this.element,
+                this.htmlElement,
                 {
                     autoBind: false,
                     legend: properties.legend,
                     dataSource: this.dataSource,
                     chartArea: properties.chartArea,
-                    series: unwrap(properties.series),
-                    categoryAxis: unwrap(properties.categoryAxis),
+                    series: observable.unwrap(properties.series),
+                    categoryAxis: observable.unwrap(properties.categoryAxis),
                     valueAxis: properties.valueAxis
                 }
             );
         });
 
-        if (isSubscribable(properties.series)) {
+        if (observable.isSubscribable(properties.series)) {
             this.disposers.push(
                 properties.series.subscribe((series) => {
                     if (this.chart) {
@@ -79,14 +77,14 @@ export class ChartElement extends Element<IChartProperties>{
             );
         }
 
-        if (isSubscribable(properties.categoryAxis)) {
+        if (observable.isSubscribable(properties.categoryAxis)) {
             this.disposers.push(
-                properties.categoryAxis.subscribe((categoryAxis)=>{
-                                            if (this.chart) {
-                            this.chart.setOptions({
-                                categoryAxis: categoryAxis
-                            });
-                        }
+                properties.categoryAxis.subscribe((categoryAxis) => {
+                    if (this.chart) {
+                        this.chart.setOptions({
+                            categoryAxis: categoryAxis
+                        });
+                    }
                 })
             );
         }