@datagrok-libraries/bio 0.0.4 → 0.0.8

package/src/viewers/web-logo.js

@@ -0,0 +1,345 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import * as rxjs from 'rxjs';
+import { Aminoacids, AminoacidsPalettes } from '../aminoacids';
+import { Nucleotides, NucleotidesPalettes } from '../nucleotides';
+HTMLCanvasElement.prototype.getCursorPosition = function (event) {
+    const rect = this.getBoundingClientRect();
+    return new DG.Point(event.clientX - rect.left, event.clientY - rect.top);
+};
+DG.Rect.prototype.contains = function (x, y) {
+    return this.left <= x && x <= this.right && this.top <= y && y <= this.bottom;
+};
+export class PositionMonomerInfo {
+    constructor() {
+        this.count = 0;
+        this.bounds = new DG.Rect(0, 0, 0, 0);
+    }
+}
+export class PositionInfo {
+    /** freq = {}, rowCount = 0
+     * @param {string} name Name of position ('111A', '111.1', etc)
+     */
+    constructor(name) {
+        this.name = name;
+        this.freq = {};
+        this.rowCount = 0;
+    }
+}
+export class WebLogo extends DG.JsViewer {
+    constructor() {
+        super();
+        // private readonly colorScheme: ColorScheme = ColorSchemes[NucleotidesWebLogo.residuesSet];
+        this.cp = null;
+        this.axisHeight = 12;
+        this.positionWidth = 16;
+        this.seqCol = null;
+        // private maxLength: number = 100;
+        this.positions = [];
+        this.rowsMasked = 0;
+        this.rowsNull = 0;
+        this.positionNames = [];
+        this.startPosition = -1;
+        this.endPosition = -1;
+        this.textBaseline = 'top';
+        this.minHeight = this.float('minHeight', 50);
+        this.maxHeight = this.float('maxHeight', 100);
+        this.considerNullSequences = this.bool('considerNullSequences', false);
+        this.sequenceColumnName = this.string('sequenceColumnName', null);
+        this.startPositionName = this.string('startPositionName', null);
+        this.endPositionName = this.string('endPositionName', null);
+    }
+    get Length() { return this.endPosition - this.startPosition + 1; }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.canvas = ui.canvas();
+            this.canvas.style.width = '100%';
+            this.slider = ui.rangeSlider(0, 20, 2, 5);
+            this.slider.root.style.width = '100%';
+            this.slider.root.style.height = '12px';
+            // this.host = ui.divV([/*this.slider,*/this.canvas]);
+            const getMonomer = (p) => {
+                const jPos = Math.floor(p.x / this.positionWidth);
+                const position = this.positions[jPos];
+                if (position === void 0)
+                    return [jPos, null, null];
+                const monomer = Object.keys(position.freq)
+                    .find((m) => position.freq[m].bounds.contains(p.x, p.y));
+                if (monomer === undefined)
+                    return [jPos, null, null];
+                return [jPos, monomer, position.freq[monomer]];
+            };
+            this.canvas.onmouseover = (e) => {
+            };
+            rxjs.fromEvent(this.canvas, 'mousemove').subscribe((e) => {
+                if (!this.canvas)
+                    return;
+                const args = e;
+                const [jPos, monomer] = getMonomer(this.canvas.getCursorPosition(args));
+                //if (this.dataFrame && this.seqCol && monomer) {
+                if (this.dataFrame && this.seqCol && monomer) {
+                    ui.tooltip.showRowGroup(this.dataFrame, (iRow) => {
+                        const seq = this.seqCol.get(iRow);
+                        const mSeq = seq ? seq[this.startPosition + jPos] : null;
+                        return mSeq === monomer;
+                    }, args.x + 16, args.y + 16);
+                }
+                else {
+                    ui.tooltip.hide();
+                }
+            });
+            rxjs.fromEvent(this.canvas, 'mousedown').subscribe((e) => {
+                if (!this.canvas)
+                    return;
+                const args = e;
+                const [jPos, monomer] = getMonomer(this.canvas.getCursorPosition(args));
+                // prevents deselect all rows if we miss monomer bounds
+                //if (this.dataFrame && this.seqCol && monomer) {
+                if (this.dataFrame && this.seqCol && monomer) {
+                    this.dataFrame.selection.init((iRow) => {
+                        const seq = this.seqCol.get(iRow);
+                        const mSeq = seq ? seq[this.startPosition + jPos] : null;
+                        return mSeq === monomer;
+                    });
+                }
+            });
+            this.root.append(this.canvas);
+            // this.root.appendChild(this.slider.root);
+            // this.root.append(this.host);
+            // ui.onSizeChanged(this.canvas).subscribe(this.canvasOnSizeChanged.bind(this));
+            ui.onSizeChanged(this.root).subscribe(this.rootOnSizeChanged.bind(this));
+            this.render(true);
+        });
+    }
+    // canvasOnSizeChanged(args: any) {
+    //   this.canvas.width = this.canvas.clientWidth;
+    //   this.canvas.height = this.canvas.clientHeight;
+    //   console.debug(`WebLogo.onSizeChanged() width=${this.canvas.width}, height=${this.canvas.height}`);
+    //   this.render(false);
+    // }
+    rootOnSizeChanged(args) {
+        if (!this.canvas)
+            return;
+        // this.canvas.width calculate in this._calculate() method
+        const height = Math.min(this.maxHeight, Math.max(this.minHeight, this.root.clientHeight));
+        // if (this.canvas.width > this.root.clientWidth) /* horizontal scroller is enabled */
+        //   height -= 6; /* free some space for horizontal scroller */
+        this.canvas.height = height;
+        this.canvas.style.height = `${height}px`;
+        // console.debug(`WebLogo.onRootSizeChanged() ` +
+        //   `root.width=${this.root.clientWidth}, root.height=${this.root.clientHeight}, ` +
+        //   `canvas.width=${this.canvas.width}, canvas.height=${this.canvas.height} .`);
+        this.render(true);
+    }
+    /** Assigns {@link seqCol} and {@link cp} based on {@link sequenceColumnName} and calls {@link render}().
+     */
+    updateSeqCol() {
+        if (this.dataFrame) {
+            this.seqCol = this.dataFrame.col(this.sequenceColumnName);
+            if (this.seqCol) {
+                let maxLength = 0;
+                for (const category of this.seqCol.categories)
+                    maxLength = Math.max(maxLength, category.length);
+                // Get position names from data column tag 'positionNames'
+                const positionNamesTxt = this.seqCol.getTag('positionNames');
+                // Fallback if 'positionNames' tag is not provided
+                this.positionNames = positionNamesTxt ? positionNamesTxt.split(', ').map((n) => n.trim()) :
+                    [...Array(maxLength).keys()].map((jPos) => `${jPos + 1}`);
+                this.startPosition = this.startPositionName && this.positionNames ?
+                    this.positionNames.indexOf(this.startPositionName) : 0;
+                this.endPosition = this.endPositionName && this.positionNames ?
+                    this.positionNames.indexOf(this.endPositionName) : maxLength;
+                //#region -- palette --
+                switch (this.seqCol.semType) {
+                    case Aminoacids.SemTypeMultipleAlignment:
+                        this.cp = AminoacidsPalettes.GrokGroups;
+                        break;
+                    case Nucleotides.SemTypeMultipleAlignment:
+                        this.cp = NucleotidesPalettes.Chromatogram;
+                        break;
+                }
+                //#endregion -- palette --
+            }
+            else {
+                this.cp = null;
+                this.positionNames = [];
+                this.startPosition = -1;
+                this.endPosition = -1;
+            }
+        }
+        this.render();
+    }
+    onPropertyChanged(property) {
+        super.onPropertyChanged(property);
+        switch (property.name) {
+            case 'considerNullSequences':
+                this.render();
+                break;
+            case 'sequenceColumnName':
+                this.updateSeqCol();
+                break;
+            case 'startPositionName':
+                this.updateSeqCol();
+                break;
+            case 'endPositionName':
+                this.updateSeqCol();
+                break;
+            case 'minHeight':
+                this.render(true);
+                break;
+            case 'maxHeight':
+                this.render(true);
+                break;
+        }
+    }
+    onTableAttached() {
+        this.updateSeqCol();
+        if (this.dataFrame !== void 0) {
+            // There are two approaches:
+            // first  - look in the dataFrame for the first matching column by semType of the
+            //          corresponding viewer (but we want only one class of a more universal viewer),
+            // second - draw column data if the passed column is of suitable semType
+            // We decided that we will not search, but we will display asked data if we can
+            // const semType = (<typeof NucleotidesWebLogo>(this.constructor)).residuesSet;
+            // this.seqCol = (this.dataFrame.columns as DG.ColumnList).bySemType(semType);
+            this.dataFrame.selection.onChanged.subscribe((_) => this.render());
+            this.dataFrame.filter.onChanged.subscribe((_) => this.render());
+        }
+    }
+    _nullSequence(fillerResidue = 'X') {
+        if (this.considerNullSequences)
+            return new Array(this.Length).fill(fillerResidue).join('');
+        return '';
+    }
+    _calculate() {
+        if (!this.canvas || !this.seqCol || !this.dataFrame || this.startPosition === -1 || this.endPosition === -1)
+            return;
+        const width = this.Length * this.positionWidth;
+        this.canvas.width = width;
+        this.canvas.style.width = `${width}px`;
+        this.root.style.width = `${this.canvas.width}px`;
+        this.positions = new Array(this.Length);
+        for (let jPos = 0; jPos < this.Length; jPos++) {
+            const posName = this.positionNames[this.startPosition + jPos];
+            this.positions[jPos] = new PositionInfo(posName);
+        }
+        // 2022-05-05 askalkin instructed to show WebLogo based on filter (not selection)
+        const indices = this.dataFrame.filter.getSelectedIndexes();
+        // const indices = this.dataFrame.selection.trueCount > 0 ? this.dataFrame.selection.getSelectedIndexes() :
+        //   this.dataFrame.filter.getSelectedIndexes();
+        this.rowsMasked = indices.length;
+        this.rowsNull = 0;
+        for (const i of indices) {
+            let s = (this.seqCol.get(i));
+            if (!s) {
+                s = this._nullSequence();
+                ++this.rowsNull;
+            }
+            else {
+                for (let jPos = 0; jPos < this.Length; jPos++) {
+                    const pmInfo = this.positions[jPos].freq;
+                    const m = s[this.startPosition + jPos];
+                    if (!(m in pmInfo))
+                        pmInfo[m] = new PositionMonomerInfo();
+                    pmInfo[m].count++;
+                }
+            }
+        }
+        //#region Polish freq counts
+        for (let jPos = 0; jPos < this.Length; jPos++) {
+            // delete this.positions[jPos].freq['-'];
+            this.positions[jPos].rowCount = 0;
+            for (const m in this.positions[jPos].freq)
+                this.positions[jPos].rowCount += this.positions[jPos].freq[m].count;
+        }
+        //#endregion
+        const maxHeight = this.canvas.height - this.axisHeight;
+        // console.debug(`WebLogo._calculate() maxHeight=${maxHeight}.`);
+        //#region Calculate screen
+        for (let jPos = 0; jPos < this.Length; jPos++) {
+            const freq = this.positions[jPos].freq;
+            const rowCount = this.positions[jPos].rowCount;
+            let y = this.axisHeight;
+            const entries = Object.entries(freq).sort((a, b) => {
+                if (a[0] !== '-' && b[0] !== '-')
+                    return b[1].count - a[1].count;
+                else if (a[0] === '-' && b[0] === '-')
+                    return 0;
+                else if (a[0] === '-')
+                    return -1;
+                else /* (b[0] === '-') */
+                    return +1;
+            });
+            for (const entry of entries) {
+                const pmInfo = entry[1];
+                // const m: string = entry[0];
+                const h = maxHeight * pmInfo.count / rowCount;
+                pmInfo.bounds = new DG.Rect(jPos * this.positionWidth, y, this.positionWidth, h);
+                y += h;
+            }
+        }
+        //#endregion
+    }
+    // reflect changes made to filter/selection
+    render(recalc = true) {
+        var _a;
+        if (!this.canvas || !this.seqCol || !this.dataFrame || !this.cp ||
+            this.startPosition === -1 || this.endPosition === -1)
+            return;
+        const g = this.canvas.getContext('2d');
+        if (!g)
+            return;
+        if (recalc)
+            this._calculate();
+        // let rowCount = this.rowsMasked;
+        // if (!this.considerNullSequences)
+        //   rowCount -= this.rowsNull;
+        g.resetTransform();
+        g.clearRect(0, 0, this.canvas.width, this.canvas.height);
+        g.textBaseline = this.textBaseline;
+        for (let jPos = 0; jPos < this.Length; jPos++) {
+            const pos = this.positions[jPos];
+            g.resetTransform();
+            g.fillStyle = 'black';
+            g.textAlign = 'center';
+            g.font = '10px Roboto, Roboto Local, sans-serif';
+            const posNameTm = g.measureText(pos.name);
+            const jPosWidth = posNameTm.width < (this.positionWidth - 2) ? posNameTm.width : (this.positionWidth - 2);
+            g.setTransform(jPosWidth / posNameTm.width, 0, 0, 1, jPos * this.positionWidth + this.positionWidth / 2, 0);
+            g.fillText(pos.name, 0, 0);
+            for (const [monomer, pmInfo] of Object.entries(this.positions[jPos].freq)) {
+                if (monomer !== '-') {
+                    const b = pmInfo.bounds;
+                    const fontStyle = '16px Roboto, Roboto Local, sans-serif';
+                    // Hacks to scale uppercase characters to target rectangle
+                    const uppercaseLetterAscent = 0.25;
+                    const uppercaseLetterHeight = 12.2;
+                    g.resetTransform();
+                    g.strokeStyle = 'lightgray';
+                    g.lineWidth = 1;
+                    g.rect(b.left, b.top, b.width, b.height);
+                    g.fillStyle = (_a = this.cp[monomer]) !== null && _a !== void 0 ? _a : this.cp['other'];
+                    g.textAlign = 'left';
+                    g.font = fontStyle;
+                    //g.fillRect(b.left, b.top, b.width, b.height);
+                    const mTm = g.measureText(monomer);
+                    // if (mM.actualBoundingBoxAscent != 0)
+                    //   console.debug(`m: ${m}, mM.actualBoundingBoxAscent: ${mM.actualBoundingBoxAscent}`);
+                    g.setTransform(b.width / mTm.width, 0, 0, b.height / uppercaseLetterHeight, b.left, b.top);
+                    g.fillText(monomer, 0, -uppercaseLetterAscent);
+                }
+            }
+        }
+    }
+}
+WebLogo.residuesSet = 'nucleotides';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-logo.js","sourceRoot":"","sources":["web-logo.ts"],"names":[],"mappings":"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","sourcesContent":["import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport * as rxjs from 'rxjs';\n\nimport {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';\n\nimport {Aminoacids, AminoacidsPalettes} from '../aminoacids';\nimport {Nucleotides, NucleotidesPalettes} from '../nucleotides';\n\n// Using color schemes from chem-palette\n\ndeclare module 'datagrok-api/src/grid' {\n  interface Rect {\n    contains(x: number, y: number): boolean;\n  }\n}\n\ndeclare global {\n  interface HTMLCanvasElement {\n    getCursorPosition(event: MouseEvent): DG.Point;\n  }\n}\n\nHTMLCanvasElement.prototype.getCursorPosition = function(event: MouseEvent): DG.Point {\n  const rect = this.getBoundingClientRect();\n  return new DG.Point(event.clientX - rect.left, event.clientY - rect.top);\n};\n\nDG.Rect.prototype.contains = function(x: number, y: number): boolean {\n  return this.left <= x && x <= this.right && this.top <= y && y <= this.bottom;\n};\n\nexport class PositionMonomerInfo {\n  /** Sequences count with monomer in position\n   */\n  count: number;\n\n  /** Remember screen coords rect\n   */\n  bounds: DG.Rect;\n\n  constructor() {\n    this.count = 0;\n    this.bounds = new DG.Rect(0, 0, 0, 0);\n  }\n}\n\nexport class PositionInfo {\n  public readonly name: string;\n  freq: { [m: string]: PositionMonomerInfo };\n  rowCount: number;\n\n  /** freq = {}, rowCount = 0\n   * @param {string} name Name of position ('111A', '111.1', etc)\n   */\n  constructor(name: string) {\n    this.name = name;\n    this.freq = {};\n    this.rowCount = 0;\n  }\n}\n\nexport class WebLogo extends DG.JsViewer {\n  public static residuesSet = 'nucleotides';\n\n  // private readonly colorScheme: ColorScheme = ColorSchemes[NucleotidesWebLogo.residuesSet];\n  protected cp: StringDictionary | null = null;\n\n  // private readonly host: HTMLDivElement;\n  private canvas?: HTMLCanvasElement;\n  private slider?: DG.RangeSlider;\n  private textBaseline: CanvasTextBaseline;\n\n  private axisHeight: number = 12;\n  private positionWidth: number = 16;\n\n  private seqCol: DG.Column | null = null;\n  // private maxLength: number = 100;\n  private positions: PositionInfo[] = [];\n\n  private rowsMasked: number = 0;\n  private rowsNull: number = 0;\n\n  // Viewer's properties (likely they should be public so that they can be set outside)\n  public minHeight: number;\n  public maxHeight: number;\n  public considerNullSequences: boolean;\n  public sequenceColumnName: string;\n  public startPositionName: string;\n  public endPositionName: string;\n\n  private positionNames: string[] = [];\n\n  private startPosition: number = -1;\n\n  private endPosition: number = -1;\n\n  private get Length(): number { return this.endPosition - this.startPosition + 1; }\n\n  constructor() {\n    super();\n\n    this.textBaseline = 'top';\n\n    this.minHeight = this.float('minHeight', 50);\n    this.maxHeight = this.float('maxHeight', 100);\n\n    this.considerNullSequences = this.bool('considerNullSequences', false);\n    this.sequenceColumnName = this.string('sequenceColumnName', null);\n\n    this.startPositionName = this.string('startPositionName', null);\n    this.endPositionName = this.string('endPositionName', null);\n  }\n\n  async init(): Promise<void> {\n    this.canvas = ui.canvas();\n    this.canvas.style.width = '100%';\n\n    this.slider = ui.rangeSlider(0, 20, 2, 5);\n    this.slider.root.style.width = '100%';\n    this.slider.root.style.height = '12px';\n\n    // this.host = ui.divV([/*this.slider,*/this.canvas]);\n\n    const getMonomer = (p: DG.Point): [number, string | null, PositionMonomerInfo | null] => {\n      const jPos = Math.floor(p.x / this.positionWidth);\n      const position = this.positions[jPos];\n\n      if (position === void 0)\n        return [jPos, null, null];\n\n      const monomer: string | undefined = Object.keys(position.freq)\n        .find((m) => position.freq[m].bounds.contains(p.x, p.y));\n      if (monomer === undefined)\n        return [jPos, null, null];\n\n      return [jPos, monomer, position.freq[monomer]];\n    };\n\n    this.canvas.onmouseover = (e: MouseEvent) => {\n\n    };\n\n    rxjs.fromEvent(this.canvas, 'mousemove').subscribe((e: Event) => {\n      if (!this.canvas)\n        return;\n\n      const args = e as MouseEvent;\n      const [jPos, monomer] = getMonomer(this.canvas.getCursorPosition(args));\n\n      //if (this.dataFrame && this.seqCol && monomer) {\n      if (this.dataFrame && this.seqCol && monomer) {\n        ui.tooltip.showRowGroup(this.dataFrame, (iRow) => {\n          const seq = this.seqCol!.get(iRow);\n          const mSeq = seq ? seq[this.startPosition + jPos] : null;\n          return mSeq === monomer;\n        }, args.x + 16, args.y + 16);\n      } else {\n        ui.tooltip.hide();\n      }\n    });\n\n    rxjs.fromEvent(this.canvas, 'mousedown').subscribe((e: Event) => {\n      if (!this.canvas)\n        return;\n\n      const args = e as MouseEvent;\n      const [jPos, monomer] = getMonomer(this.canvas.getCursorPosition(args));\n\n      // prevents deselect all rows if we miss monomer bounds\n      //if (this.dataFrame && this.seqCol && monomer) {\n      if (this.dataFrame && this.seqCol && monomer) {\n        this.dataFrame.selection.init((iRow) => {\n          const seq = this.seqCol!.get(iRow);\n          const mSeq = seq ? seq[this.startPosition + jPos] : null;\n          return mSeq === monomer;\n        });\n      }\n    });\n\n    this.root.append(this.canvas);\n    // this.root.appendChild(this.slider.root);\n    // this.root.append(this.host);\n\n    // ui.onSizeChanged(this.canvas).subscribe(this.canvasOnSizeChanged.bind(this));\n    ui.onSizeChanged(this.root).subscribe(this.rootOnSizeChanged.bind(this));\n\n    this.render(true);\n  }\n\n  // canvasOnSizeChanged(args: any) {\n  //   this.canvas.width = this.canvas.clientWidth;\n  //   this.canvas.height = this.canvas.clientHeight;\n  //   console.debug(`WebLogo.onSizeChanged() width=${this.canvas.width}, height=${this.canvas.height}`);\n  //   this.render(false);\n  // }\n\n  rootOnSizeChanged(args: any) {\n    if (!this.canvas)\n      return;\n\n    // this.canvas.width calculate in this._calculate() method\n\n    const height = Math.min(this.maxHeight, Math.max(this.minHeight, this.root.clientHeight));\n    // if (this.canvas.width > this.root.clientWidth) /* horizontal scroller is enabled */\n    //   height -= 6; /* free some space for horizontal scroller */\n    this.canvas.height = height;\n    this.canvas.style.height = `${height}px`;\n\n    // console.debug(`WebLogo.onRootSizeChanged() ` +\n    //   `root.width=${this.root.clientWidth}, root.height=${this.root.clientHeight}, ` +\n    //   `canvas.width=${this.canvas.width}, canvas.height=${this.canvas.height} .`);\n\n    this.render(true);\n  }\n\n  /** Assigns {@link seqCol} and {@link cp} based on {@link sequenceColumnName} and calls {@link render}().\n   */\n  updateSeqCol(): void {\n    if (this.dataFrame) {\n      this.seqCol = this.dataFrame.col(this.sequenceColumnName);\n      if (this.seqCol) {\n        let maxLength = 0;\n        for (const category of this.seqCol.categories)\n          maxLength = Math.max(maxLength, category.length);\n\n        // Get position names from data column tag 'positionNames'\n        const positionNamesTxt = this.seqCol.getTag('positionNames');\n        // Fallback if 'positionNames' tag is not provided\n        this.positionNames = positionNamesTxt ? positionNamesTxt.split(', ').map((n) => n.trim()) :\n          [...Array(maxLength).keys()].map((jPos) => `${jPos + 1}`);\n\n        this.startPosition = this.startPositionName && this.positionNames ?\n          this.positionNames.indexOf(this.startPositionName) : 0;\n        this.endPosition = this.endPositionName && this.positionNames ?\n          this.positionNames.indexOf(this.endPositionName) : maxLength;\n\n        //#region -- palette --\n        switch (this.seqCol.semType) {\n        case Aminoacids.SemTypeMultipleAlignment:\n          this.cp = AminoacidsPalettes.GrokGroups;\n          break;\n        case Nucleotides.SemTypeMultipleAlignment:\n          this.cp = NucleotidesPalettes.Chromatogram;\n          break;\n        }\n        //#endregion -- palette --\n      } else {\n        this.cp = null;\n        this.positionNames = [];\n        this.startPosition = -1;\n        this.endPosition = -1;\n      }\n    }\n    this.render();\n  }\n\n  onPropertyChanged(property: DG.Property): void {\n    super.onPropertyChanged(property);\n\n    switch (property.name) {\n    case 'considerNullSequences':\n      this.render();\n      break;\n    case 'sequenceColumnName':\n      this.updateSeqCol();\n      break;\n    case 'startPositionName':\n      this.updateSeqCol();\n      break;\n    case 'endPositionName':\n      this.updateSeqCol();\n      break;\n    case 'minHeight':\n      this.render(true);\n      break;\n    case 'maxHeight':\n      this.render(true);\n      break;\n    }\n  }\n\n  onTableAttached() {\n    this.updateSeqCol();\n\n    if (this.dataFrame !== void 0) {\n      // There are two approaches:\n      // first  - look in the dataFrame for the first matching column by semType of the\n      //          corresponding viewer (but we want only one class of a more universal viewer),\n      // second - draw column data if the passed column is of suitable semType\n      // We decided that we will not search, but we will display asked data if we can\n      // const semType = (<typeof NucleotidesWebLogo>(this.constructor)).residuesSet;\n      // this.seqCol = (this.dataFrame.columns as DG.ColumnList).bySemType(semType);\n\n      this.dataFrame.selection.onChanged.subscribe((_) => this.render());\n      this.dataFrame.filter.onChanged.subscribe((_) => this.render());\n    }\n  }\n\n  protected _nullSequence(fillerResidue = 'X'): string {\n    if (this.considerNullSequences)\n      return new Array(this.Length).fill(fillerResidue).join('');\n\n    return '';\n  }\n\n  protected _calculate() {\n    if (!this.canvas || !this.seqCol || !this.dataFrame || this.startPosition === -1 || this.endPosition === -1)\n      return;\n\n    const width = this.Length * this.positionWidth;\n    this.canvas.width = width;\n    this.canvas.style.width = `${width}px`;\n    this.root.style.width = `${this.canvas.width}px`;\n\n    this.positions = new Array(this.Length);\n    for (let jPos = 0; jPos < this.Length; jPos++) {\n      const posName: string = this.positionNames[this.startPosition + jPos];\n      this.positions[jPos] = new PositionInfo(posName);\n    }\n\n    // 2022-05-05 askalkin instructed to show WebLogo based on filter (not selection)\n    const indices = this.dataFrame.filter.getSelectedIndexes();\n    // const indices = this.dataFrame.selection.trueCount > 0 ? this.dataFrame.selection.getSelectedIndexes() :\n    //   this.dataFrame.filter.getSelectedIndexes();\n\n    this.rowsMasked = indices.length;\n    this.rowsNull = 0;\n\n    for (const i of indices) {\n      let s: string = <string>(this.seqCol.get(i));\n\n      if (!s) {\n        s = this._nullSequence();\n        ++this.rowsNull;\n      } else {\n        for (let jPos = 0; jPos < this.Length; jPos++) {\n          const pmInfo = this.positions[jPos].freq;\n          const m: string = s[this.startPosition + jPos];\n          if (!(m in pmInfo))\n            pmInfo[m] = new PositionMonomerInfo();\n\n          pmInfo[m].count++;\n        }\n      }\n    }\n\n    //#region Polish freq counts\n    for (let jPos = 0; jPos < this.Length; jPos++) {\n      // delete this.positions[jPos].freq['-'];\n\n      this.positions[jPos].rowCount = 0;\n      for (const m in this.positions[jPos].freq)\n        this.positions[jPos].rowCount += this.positions[jPos].freq[m].count;\n    }\n    //#endregion\n\n    const maxHeight = this.canvas.height - this.axisHeight;\n    // console.debug(`WebLogo._calculate() maxHeight=${maxHeight}.`);\n\n    //#region Calculate screen\n    for (let jPos = 0; jPos < this.Length; jPos++) {\n      const freq: { [c: string]: PositionMonomerInfo } = this.positions[jPos].freq;\n      const rowCount = this.positions[jPos].rowCount;\n\n      let y: number = this.axisHeight;\n\n      const entries = Object.entries(freq).sort((a, b) => {\n        if (a[0] !== '-' && b[0] !== '-')\n          return b[1].count - a[1].count;\n        else if (a[0] === '-' && b[0] === '-')\n          return 0;\n        else if (a[0] === '-')\n          return -1;\n        else /* (b[0] === '-') */\n          return +1;\n      });\n      for (const entry of entries) {\n        const pmInfo: PositionMonomerInfo = entry[1];\n        // const m: string = entry[0];\n        const h: number = maxHeight * pmInfo.count / rowCount;\n\n        pmInfo.bounds = new DG.Rect(jPos * this.positionWidth, y, this.positionWidth, h);\n        y += h;\n      }\n    }\n    //#endregion\n  }\n\n  // reflect changes made to filter/selection\n  render(recalc = true) {\n    if (!this.canvas || !this.seqCol || !this.dataFrame || !this.cp ||\n      this.startPosition === -1 || this.endPosition === -1)\n      return;\n\n    const g = this.canvas.getContext('2d');\n    if (!g) return;\n\n    if (recalc)\n      this._calculate();\n\n    // let rowCount = this.rowsMasked;\n    // if (!this.considerNullSequences)\n    //   rowCount -= this.rowsNull;\n\n    g.resetTransform();\n    g.clearRect(0, 0, this.canvas.width, this.canvas.height);\n    g.textBaseline = this.textBaseline;\n\n    for (let jPos = 0; jPos < this.Length; jPos++) {\n      const pos: PositionInfo = this.positions[jPos];\n      g.resetTransform();\n      g.fillStyle = 'black';\n      g.textAlign = 'center';\n      g.font = '10px Roboto, Roboto Local, sans-serif';\n      const posNameTm: TextMetrics = g.measureText(pos.name);\n      const jPosWidth = posNameTm.width < (this.positionWidth - 2) ? posNameTm.width : (this.positionWidth - 2);\n      g.setTransform(\n        jPosWidth / posNameTm.width, 0, 0, 1,\n        jPos * this.positionWidth + this.positionWidth / 2, 0);\n      g.fillText(pos.name, 0, 0);\n\n      for (const [monomer, pmInfo] of Object.entries(this.positions[jPos].freq)) {\n        if (monomer !== '-') {\n          const b = pmInfo.bounds;\n\n          const fontStyle = '16px Roboto, Roboto Local, sans-serif';\n          // Hacks to scale uppercase characters to target rectangle\n          const uppercaseLetterAscent = 0.25;\n          const uppercaseLetterHeight = 12.2;\n\n          g.resetTransform();\n          g.strokeStyle = 'lightgray';\n          g.lineWidth = 1;\n          g.rect(b.left, b.top, b.width, b.height);\n          g.fillStyle = this.cp[monomer] ?? this.cp['other'];\n          g.textAlign = 'left';\n          g.font = fontStyle;\n          //g.fillRect(b.left, b.top, b.width, b.height);\n          const mTm: TextMetrics = g.measureText(monomer);\n\n          // if (mM.actualBoundingBoxAscent != 0)\n          //   console.debug(`m: ${m}, mM.actualBoundingBoxAscent: ${mM.actualBoundingBoxAscent}`);\n\n          g.setTransform(\n            b.width / mTm.width, 0, 0, b.height / uppercaseLetterHeight,\n            b.left, b.top);\n          g.fillText(monomer, 0, -uppercaseLetterAscent);\n        }\n      }\n    }\n  }\n}\n"]}

package/tsconfig.json

@@ -1,71 +1,71 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-    /* Basic Options */
-    // "incremental": true,                         /* Enable incremental compilation */
-    "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
-    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
-    // "allowJs": true,                             /* Allow javascript files to be compiled. */
-    // "checkJs": true,                             /* Report errors in .js files. */
-    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
-     "declaration": true,                         /* Generates corresponding '.d.ts' file. */
-     "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
-    // "outFile": "./",                             /* Concatenate and emit output to single file. */
-    // "outDir": "./",                              /* Redirect output structure to the directory. */
-    // "rootDir": "./",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
-    // "composite": true,                           /* Enable project compilation */
-    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
-    // "removeComments": true,                      /* Do not emit comments to output. */
-    // "noEmit": true,                              /* Do not emit outputs. */
-    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
-    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true,                                 /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                    /* Enable strict null checks. */
-    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
-    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
-    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
-    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
-
-    /* Additional Checks */
-    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
-    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
-    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
-    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
-    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
-
-    /* Module Resolution Options */
-    "moduleResolution": "node",                     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                             /* List of folders to include type definitions from. */
-    // "types": [],                                 /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
-    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
-
-    /* Source Map Options */
-    "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
-    "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
-    "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
-    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
-
-    /* Advanced Options */
-    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
-    "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
-  }
-}
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+     "declaration": true,                         /* Generates corresponding '.d.ts' file. */
+     "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    // "outDir": "./",                              /* Redirect output structure to the directory. */
+    // "rootDir": "./",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                                 /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",                     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
+  }
+}