@datagrok/helm 2.3.2 → 2.3.3

package/src/tests/get-monomer-tests.ts

@@ -19,12 +19,8 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {defaultMonomerLibSummary, expectMonomerLib} from '@datagrok-libraries/bio/src/tests/monomer-lib-tests';
 
-import {getMonomerHandleArgs} from '../utils/get-monomer';
+import {getMonomerHandleArgs, rewriteLibraries} from '../utils/get-monomer';
 import {JSDraw2HelmModule, OrgHelmModule} from '../types';
-
-import {HelmHelper} from '../helm-helper';
-import {RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from '../constants';
-import {getRS} from '../utils/get-monomer-dummy';
 import {initHelmMainPackage} from './utils';
 
 import {_package} from '../package-test';
@@ -233,47 +229,3 @@ export function expectObjectWithNull(actual: { [key: string]: any }, expected: {
     }
   }
 }
-
-/** Fills org.helm.webeditor.Monomers dictionary for WebEditor */
-function rewriteLibraries(monomerLib: IMonomerLib): void {
-  org.helm.webeditor.Monomers.clear();
-  monomerLib!.getPolymerTypes().forEach((polymerType) => {
-    const monomerSymbols = monomerLib!.getMonomerSymbolsByType(polymerType);
-    monomerSymbols.forEach((monomerSymbol) => {
-      let isBroken = false;
-      const monomer: Monomer = monomerLib!.getMonomer(polymerType, monomerSymbol)!;
-      const webEditorMonomer: IWebEditorMonomer = {
-        id: monomerSymbol,
-        m: monomer.molfile,
-        n: monomer.name,
-        na: monomer.naturalAnalog,
-        rs: monomer.rgroups.length,
-        type: monomer.polymerType,
-        mt: monomer.monomerType,
-        at: {},
-      };
-
-      if (monomer.rgroups.length > 0) {
-        // @ts-ignore
-        webEditorMonomer.rs = monomer.rgroups.length;
-        const at: { [prop: string]: any } = {};
-        monomer.rgroups.forEach((it) => {
-          at[it[RGROUP_LABEL]] = it[RGROUP_CAP_GROUP_NAME];
-        });
-        webEditorMonomer.at = at;
-      } else if (monomer[SMILES] != null) {
-        // @ts-ignore
-        webEditorMonomer.rs = Object.keys(getRS(monomer[SMILES].toString())).length;
-        webEditorMonomer.at = getRS(monomer[SMILES].toString());
-      } else
-        isBroken = true;
-
-      if (!isBroken)
-        org.helm.webeditor.Monomers.addOneMonomer(webEditorMonomer);
-    });
-  });
-
-  // Obsolete
-  const grid: DG.Grid = grok.shell.tv?.grid;
-  if (grid) grid.invalidate();
-}

package/src/utils/get-monomer.ts

@@ -11,9 +11,13 @@ import {
 } from '@datagrok-libraries/bio/src/utils/const';
 import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 
-import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer} from './get-monomer-dummy';
+
+import {
+  AmbiguousWebEditorMonomer, GapWebEditorMonomer, getRS, MissingWebEditorMonomer
+} from './get-monomer-dummy';
 import {LibraryWebEditorMonomer} from './get-monomer-of-library';
 import {OrgHelmModule, ScilModule} from '../types';
+import {RGROUP_CAP_GROUP_NAME, RGROUP_LABEL, SMILES} from '../constants';
 
 import {_package} from '../package';
 
@@ -111,3 +115,47 @@ export function getWebEditorMonomer(
 
   return resWem;
 }
+
+/** Fills org.helm.webeditor.Monomers dictionary for WebEditor */
+export function rewriteLibraries(monomerLib: IMonomerLib): void {
+  org.helm.webeditor.Monomers.clear();
+  monomerLib!.getPolymerTypes().forEach((polymerType) => {
+    const monomerSymbols = monomerLib!.getMonomerSymbolsByType(polymerType);
+    monomerSymbols.forEach((monomerSymbol) => {
+      let isBroken = false;
+      const monomer: Monomer = monomerLib!.getMonomer(polymerType, monomerSymbol)!;
+      const webEditorMonomer: IWebEditorMonomer = {
+        id: monomerSymbol,
+        m: monomer.molfile,
+        n: monomer.name,
+        na: monomer.naturalAnalog,
+        rs: monomer.rgroups.length,
+        type: monomer.polymerType,
+        mt: monomer.monomerType,
+        at: {},
+      };
+
+      if (monomer.rgroups.length > 0) {
+        // @ts-ignore
+        webEditorMonomer.rs = monomer.rgroups.length;
+        const at: { [prop: string]: any } = {};
+        monomer.rgroups.forEach((it) => {
+          at[it[RGROUP_LABEL]] = it[RGROUP_CAP_GROUP_NAME];
+        });
+        webEditorMonomer.at = at;
+      } else if (monomer[SMILES] != null) {
+        // @ts-ignore
+        webEditorMonomer.rs = Object.keys(getRS(monomer[SMILES].toString())).length;
+        webEditorMonomer.at = getRS(monomer[SMILES].toString());
+      } else
+        isBroken = true;
+
+      if (!isBroken)
+        org.helm.webeditor.Monomers.addOneMonomer(webEditorMonomer);
+    });
+  });
+
+  // Obsolete
+  const grid: DG.Grid = grok.shell.tv?.grid;
+  if (grid) grid.invalidate();
+}

package/src/utils/helm-grid-cell-renderer.ts

@@ -9,16 +9,15 @@ import {
   CellRendererBackAsyncBase, RenderServiceBase
 } from '@datagrok-libraries/bio/src/utils/cell-renderer-async-base';
 import {HelmAux, HelmProps} from '@datagrok-libraries/bio/src/viewers/helm-service';
-
-import {getHoveredMonomerFromEditorMol} from './get-hovered';
-import {_getHelmService} from '../package-utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
-
-import {_package, getMonomerLib} from '../package';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
-import {GridCell, GridCellStyle, x} from 'datagrok-api/dg';
+
+import {getHoveredMonomerFromEditorMol} from './get-hovered';
+import {_getHelmService} from '../package-utils';
+
+import {_package} from '../package';
 
 class WrapLogger implements ILogger {
   constructor(
@@ -146,7 +145,7 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
       getHoveredMonomerFromEditorMol(argsX, argsY, editorMol, gridCell.bounds.height);
 
     if (seqMonomer) {
-      const monomerLib = getMonomerLib();
+      const monomerLib = _package.monomerLib;
       const tooltipEl = monomerLib ? monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol) :
         ui.divText('Monomer library is not available');
       ui.tooltip.show(tooltipEl, e.x + 16, e.y + 16);
@@ -158,9 +157,9 @@ export class HelmGridCellRendererBack extends CellRendererBackAsyncBase<HelmProp
 
   public override render(g: CanvasRenderingContext2D,
     x: number, y: number, w: number, h: number,
-    gridCell: GridCell, cellStyle: GridCellStyle) {
+    gridCell: DG.GridCell, cellStyle: DG.GridCellStyle) {
     if (!this.monomerLib) {
-      this.monomerLib = getMonomerLib();
+      this.monomerLib = _package.monomerLib;
       if (this.monomerLib) {
         this.subs.push(this.monomerLib.onChanged.subscribe(this.monomerLibOnChanged.bind(this)));
       }

package/src/utils/index.ts

@@ -2,6 +2,7 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
 import {OrgHelmModule, ScilModule} from '../types';
 
 import {
@@ -15,7 +16,6 @@ import {
   SDF_MONOMER_NAME
 } from '../constants';
 
-import {getMonomerLib} from '../package';
 
 declare const scil: ScilModule;
 declare const org: OrgHelmModule;
@@ -113,8 +113,7 @@ export function parseHelm(s: string): string[] {
 // }
 
 /** Searches monomers of helmString for missed. */
-export function findMonomers(seqMonomerSymbolList: string[]): Set<string> {
-  const monomerLib = getMonomerLib();
+export function findMonomers(seqMonomerSymbolList: string[], monomerLib: IMonomerLib): Set<string> {
   return new Set(seqMonomerSymbolList.filter((s) => monomerLib?.getMonomer(null, s)));
 }
 

package/src/widgets/helm-input.ts

@@ -12,7 +12,7 @@ import {HelmMol, IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getHoveredMonomerFromEditorMol} from '../utils/get-hovered';
 
-import {_package, getMonomerLib} from '../package';
+import {_package} from '../package';
 
 
 export class HelmInput extends DG.JsInputBase<HelmMol> {
@@ -150,12 +150,12 @@ export class HelmInput extends DG.JsInputBase<HelmMol> {
       .add(webEditorHost!)
       .onOK(() => {
         try {
-          const webEditorValue = webEditorApp!.canvas.getHelm(true)
+          const webEditorValue = webEditorApp.canvas!.getHelm(true)
             .replace(/<\/span>/g, '').replace(/<span style='background:#bbf;'>/g, '');
           this.viewer.editor.setHelm(webEditorValue);
           this.helmString = webEditorValue;
 
-          const selection = webEditorApp!.canvas.helm.jsd.m.atoms;
+          const selection = webEditorApp.canvas!.helm!.jsd.m.atoms;
           this.helmSelection = [];
           for (let i = 0; i < selection.length; i++) {
             if (selection[i].selected)
@@ -185,7 +185,7 @@ export class HelmInput extends DG.JsInputBase<HelmMol> {
     const mol = this.viewer.editor.m;
     const seqMonomer = getHoveredMonomerFromEditorMol(argsX, argsY, mol, this.viewer.editor.div.clientHeight);
     if (seqMonomer) {
-      const monomerLib = getMonomerLib();
+      const monomerLib = _package.monomerLib;
       const tooltipEl = monomerLib ? monomerLib.getTooltip(seqMonomer.polymerType, seqMonomer.symbol) :
         ui.divText('Monomer library is not available');
       ui.tooltip.show(tooltipEl, event.x + 16, event.y + 16);

package/vendor/dojo-1.10.10/dijit/BackgroundIframe.js

@@ -0,0 +1,63 @@
+//>>built
+define("dijit/BackgroundIframe",["require","./main","dojo/_base/config","dojo/dom-construct","dojo/dom-style","dojo/_base/lang","dojo/on","dojo/sniff"],function(_1,_2,_3,_4,_5,_6,on,_7){
+_7.add("config-bgIframe",(_7("ie")||_7("trident"))&&!/IEMobile\/10\.0/.test(navigator.userAgent));
+var _8=new function(){
+var _9=[];
+this.pop=function(){
+var _a;
+if(_9.length){
+_a=_9.pop();
+_a.style.display="";
+}else{
+if(_7("ie")<9){
+var _b=_3["dojoBlankHtmlUrl"]||_1.toUrl("dojo/resources/blank.html")||"javascript:\"\"";
+var _c="<iframe src='"+_b+"' role='presentation'"+" style='position: absolute; left: 0px; top: 0px;"+"z-index: -1; filter:Alpha(Opacity=\"0\");'>";
+_a=document.createElement(_c);
+}else{
+_a=_4.create("iframe");
+_a.src="javascript:\"\"";
+_a.className="dijitBackgroundIframe";
+_a.setAttribute("role","presentation");
+_5.set(_a,"opacity",0.1);
+}
+_a.tabIndex=-1;
+}
+return _a;
+};
+this.push=function(_d){
+_d.style.display="none";
+_9.push(_d);
+};
+}();
+_2.BackgroundIframe=function(_e){
+if(!_e.id){
+throw new Error("no id");
+}
+if(_7("config-bgIframe")){
+var _f=(this.iframe=_8.pop());
+_e.appendChild(_f);
+if(_7("ie")<7||_7("quirks")){
+this.resize(_e);
+this._conn=on(_e,"resize",_6.hitch(this,"resize",_e));
+}else{
+_5.set(_f,{width:"100%",height:"100%"});
+}
+}
+};
+_6.extend(_2.BackgroundIframe,{resize:function(_10){
+if(this.iframe){
+_5.set(this.iframe,{width:_10.offsetWidth+"px",height:_10.offsetHeight+"px"});
+}
+},destroy:function(){
+if(this._conn){
+this._conn.remove();
+this._conn=null;
+}
+if(this.iframe){
+this.iframe.parentNode.removeChild(this.iframe);
+_8.push(this.iframe);
+delete this.iframe;
+}
+}});
+return _2.BackgroundIframe;
+});

package/vendor/dojo-1.10.10/dijit/BackgroundIframe.js.uncompressed.js

@@ -0,0 +1,116 @@
+define("dijit/BackgroundIframe", [
+	"require",			// require.toUrl
+	"./main",	// to export dijit.BackgroundIframe
+	"dojo/_base/config",
+	"dojo/dom-construct", // domConstruct.create
+	"dojo/dom-style", // domStyle.set
+	"dojo/_base/lang", // lang.extend lang.hitch
+	"dojo/on",
+	"dojo/sniff" // has("ie"), has("trident"), has("quirks")
+], function(require, dijit, config, domConstruct, domStyle, lang, on, has){
+
+	// module:
+	//		dijit/BackgroundIFrame
+
+	// Flag for whether to create background iframe behind popups like Menus and Dialog.
+	// A background iframe is useful to prevent problems with popups appearing behind applets/pdf files,
+	// and is also useful on older versions of IE (IE6 and IE7) to prevent the "bleed through select" problem.
+	// By default, it's enabled for IE6-11, excluding Windows Phone 8.
+	// TODO: For 2.0, make this false by default.  Also, possibly move definition to has.js so that this module can be
+	// conditionally required via  dojo/has!bgIfame?dijit/BackgroundIframe
+	has.add("config-bgIframe",
+    	(has("ie") || has("trident")) && !/IEMobile\/10\.0/.test(navigator.userAgent)); // No iframe on WP8, to match 1.9 behavior
+
+	var _frames = new function(){
+		// summary:
+		//		cache of iframes
+
+		var queue = [];
+
+		this.pop = function(){
+			var iframe;
+			if(queue.length){
+				iframe = queue.pop();
+				iframe.style.display="";
+			}else{
+				// transparency needed for DialogUnderlay and for tooltips on IE (to see screen near connector)
+				if(has("ie") < 9){
+					var burl = config["dojoBlankHtmlUrl"] || require.toUrl("dojo/resources/blank.html") || "javascript:\"\"";
+					var html="<iframe src='" + burl + "' role='presentation'"
+						+ " style='position: absolute; left: 0px; top: 0px;"
+						+ "z-index: -1; filter:Alpha(Opacity=\"0\");'>";
+					iframe = document.createElement(html);
+				}else{
+					iframe = domConstruct.create("iframe");
+					iframe.src = 'javascript:""';
+					iframe.className = "dijitBackgroundIframe";
+					iframe.setAttribute("role", "presentation");
+					domStyle.set(iframe, "opacity", 0.1);
+				}
+				iframe.tabIndex = -1; // Magic to prevent iframe from getting focus on tab keypress - as style didn't work.
+			}
+			return iframe;
+		};
+
+		this.push = function(iframe){
+			iframe.style.display="none";
+			queue.push(iframe);
+		}
+	}();
+
+
+	dijit.BackgroundIframe = function(/*DomNode*/ node){
+		// summary:
+		//		For IE/FF z-index shenanigans. id attribute is required.
+		//
+		// description:
+		//		new dijit.BackgroundIframe(node).
+		//
+		//		Makes a background iframe as a child of node, that fills
+		//		area (and position) of node
+
+		if(!node.id){ throw new Error("no id"); }
+		if(has("config-bgIframe")){
+			var iframe = (this.iframe = _frames.pop());
+			node.appendChild(iframe);
+			if(has("ie")<7 || has("quirks")){
+				this.resize(node);
+				this._conn = on(node, 'resize', lang.hitch(this, "resize", node));
+			}else{
+				domStyle.set(iframe, {
+					width: '100%',
+					height: '100%'
+				});
+			}
+		}
+	};
+
+	lang.extend(dijit.BackgroundIframe, {
+		resize: function(node){
+			// summary:
+			//		Resize the iframe so it's the same size as node.
+			//		Needed on IE6 and IE/quirks because height:100% doesn't work right.
+			if(this.iframe){
+				domStyle.set(this.iframe, {
+					width: node.offsetWidth + 'px',
+					height: node.offsetHeight + 'px'
+				});
+			}
+		},
+		destroy: function(){
+			// summary:
+			//		destroy the iframe
+			if(this._conn){
+				this._conn.remove();
+				this._conn = null;
+			}
+			if(this.iframe){
+				this.iframe.parentNode.removeChild(this.iframe);
+				_frames.push(this.iframe);
+				delete this.iframe;
+			}
+		}
+	});
+
+	return dijit.BackgroundIframe;
+});

package/vendor/dojo-1.10.10/dijit/Destroyable.js

@@ -0,0 +1,35 @@
+//>>built
+define("dijit/Destroyable",["dojo/_base/array","dojo/aspect","dojo/_base/declare"],function(_1,_2,_3){
+return _3("dijit.Destroyable",null,{destroy:function(_4){
+this._destroyed=true;
+},own:function(){
+var _5=["destroyRecursive","destroy","remove"];
+_1.forEach(arguments,function(_6){
+var _7;
+var _8=_2.before(this,"destroy",function(_9){
+_6[_7](_9);
+});
+var _a=[];
+function _b(){
+_8.remove();
+_1.forEach(_a,function(_c){
+_c.remove();
+});
+};
+if(_6.then){
+_7="cancel";
+_6.then(_b,_b);
+}else{
+_1.forEach(_5,function(_d){
+if(typeof _6[_d]==="function"){
+if(!_7){
+_7=_d;
+}
+_a.push(_2.after(_6,_d,_b,true));
+}
+});
+}
+},this);
+return arguments;
+}});
+});

package/vendor/dojo-1.10.10/dijit/Destroyable.js.uncompressed.js

@@ -0,0 +1,83 @@
+define("dijit/Destroyable", [
+	"dojo/_base/array", // array.forEach array.map
+	"dojo/aspect",
+	"dojo/_base/declare"
+], function(array, aspect, declare){
+
+	// module:
+	//		dijit/Destroyable
+
+	return declare("dijit.Destroyable", null, {
+		// summary:
+		//		Mixin to track handles and release them when instance is destroyed.
+		// description:
+		//		Call this.own(...) on list of handles (returned from dojo/aspect, dojo/on,
+		//		dojo/Stateful::watch, or any class (including widgets) with a destroyRecursive() or destroy() method.
+		//		Then call destroy() later to destroy this instance and release the resources.
+
+		destroy: function(/*Boolean*/ preserveDom){
+			// summary:
+			//		Destroy this class, releasing any resources registered via own().
+			this._destroyed = true;
+		},
+
+		own: function(){
+			// summary:
+			//		Track specified handles and remove/destroy them when this instance is destroyed, unless they were
+			//		already removed/destroyed manually.
+			// tags:
+			//		protected
+			// returns:
+			//		The array of specified handles, so you can do for example:
+			//	|		var handle = this.own(on(...))[0];
+
+			var cleanupMethods = [
+				"destroyRecursive",
+				"destroy",
+				"remove"
+			];
+
+			array.forEach(arguments, function(handle){
+				// When this.destroy() is called, destroy handle.  Since I'm using aspect.before(),
+				// the handle will be destroyed before a subclass's destroy() method starts running, before it calls
+				// this.inherited() or even if it doesn't call this.inherited() at all.  If that's an issue, make an
+				// onDestroy() method and connect to that instead.
+				var destroyMethodName;
+				var odh = aspect.before(this, "destroy", function (preserveDom){
+					handle[destroyMethodName](preserveDom);
+				});
+
+				// Callback for when handle is manually destroyed.
+				var hdhs = [];
+				function onManualDestroy(){
+					odh.remove();
+					array.forEach(hdhs, function(hdh){
+						hdh.remove();
+					});
+				}
+
+				// Setup listeners for manual destroy of handle.
+				// Also computes destroyMethodName, used in listener above.
+				if(handle.then){
+					// Special path for Promises.  Detect when Promise is resolved, rejected, or
+					// canceled (nb: cancelling a Promise causes it to be rejected).
+					destroyMethodName = "cancel";
+					handle.then(onManualDestroy, onManualDestroy);
+				}else{
+					// Path for other handles.  Just use AOP to detect when handle is manually destroyed.
+					array.forEach(cleanupMethods, function(cleanupMethod){
+						if(typeof handle[cleanupMethod] === "function"){
+							if(!destroyMethodName){
+								// Use first matching method name in above listener (prefer destroyRecursive() to destroy())
+								destroyMethodName = cleanupMethod;
+							}
+							hdhs.push(aspect.after(handle, cleanupMethod, onManualDestroy, true));
+						}
+					});
+				}
+			}, this);
+
+			return arguments;		// handle
+		}
+	});
+});