@rcsb/rcsb-saguaro-app 6.0.0-development.1 → 6.0.0-development.2

package/lib/commonjs/RcsbUtils/Helpers/Assertions.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assertions = void 0;
+var Assertions;
+(function (Assertions) {
+    function assertDefined(x, message) {
+        if (x === null || x === undefined)
+            throw message ? new Error(message) : new Error(`Undefined value`);
+    }
+    Assertions.assertDefined = assertDefined;
+    function assertElementListDefined(x, message) {
+        if (x === null || x === undefined)
+            throw new Error(`Undefined list`);
+        x.forEach((e, n) => {
+            if (e === null || x === undefined)
+                throw message ? new Error(`${message} in index ${n}`) : new Error(`Undefined value in index ${n}`);
+        });
+    }
+    Assertions.assertElementListDefined = assertElementListDefined;
+    function assertElementMatrixDefined(x, message) {
+        if (x === null || x === undefined)
+            throw new Error(`Undefined list`);
+        x.flat().forEach((e, n) => {
+            if (e === null || x === undefined)
+                throw message ? new Error(`${message} in index ${n}`) : new Error(`Undefined value in index ${n}`);
+        });
+    }
+    Assertions.assertElementMatrixDefined = assertElementMatrixDefined;
+})(Assertions || (exports.Assertions = Assertions = {}));

package/lib/commonjs/RcsbUtils/Helpers/DataContainer.d.ts

@@ -0,0 +1,9 @@
+export declare class DataContainer<T> {
+    private data;
+    constructor(data?: T);
+    get(): T | undefined;
+    set(data: T | undefined): void;
+}
+export interface DataContainerReader<T> {
+    get(): T | undefined;
+}

package/lib/commonjs/RcsbUtils/Helpers/DataContainer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataContainer = void 0;
+class DataContainer {
+    constructor(data) {
+        this.data = undefined;
+        this.data = data;
+    }
+    get() {
+        return this.data;
+    }
+    set(data) {
+        this.data = data;
+    }
+}
+exports.DataContainer = DataContainer;

package/lib/commonjs/RcsbUtils/Helpers/ObservableHelper.d.ts

@@ -0,0 +1,4 @@
+import { Subject } from "rxjs";
+export declare class ObservableHelper {
+    static oneTimeSubscription<T>(resolve: (x: T) => void, subject: Subject<T>, resolveCondition?: (x: T) => boolean): void;
+}

package/lib/commonjs/RcsbUtils/Helpers/ObservableHelper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableHelper = void 0;
+class ObservableHelper {
+    static oneTimeSubscription(resolve, subject, resolveCondition) {
+        const s = subject.subscribe({
+            next(x) {
+                if (!resolveCondition || resolveCondition(x)) {
+                    resolve(x);
+                    s.unsubscribe();
+                }
+            }
+        });
+    }
+}
+exports.ObservableHelper = ObservableHelper;

package/lib/commonjs/RcsbUtils/Helpers/Operator.d.ts

@@ -0,0 +1,5 @@
+export declare class Operator {
+    static uniqueValues<T>(array: Array<T>): T[];
+    static arrayChunk<T>(array: Array<T>, size: number): Array<Array<T>>;
+    static digitGrouping(x: string | number): string;
+}

package/lib/commonjs/RcsbUtils/Helpers/Operator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operator = void 0;
+class Operator {
+    static uniqueValues(array) {
+        return Array.from(new Set(array));
+    }
+    static arrayChunk(array, size) {
+        const out = new Array();
+        for (let i = 0; i < array.length; i += size) {
+            out.push(array.slice(i, i + size));
+        }
+        return out;
+    }
+    static digitGrouping(x) {
+        return parseFloat(x).toLocaleString('en-US');
+    }
+}
+exports.Operator = Operator;

package/lib/commonjs/RcsbUtils/Helpers/SingletonMap.d.ts

@@ -0,0 +1,4 @@
+export declare class SingletonMap {
+    private static readonly map;
+    static update(key: string, obj: any): void;
+}

package/lib/commonjs/RcsbUtils/Helpers/SingletonMap.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonMap = void 0;
+class SingletonMap {
+    static update(key, obj) {
+        if (SingletonMap.map.has(key)) {
+            Object.assign(SingletonMap.map.get(key), obj);
+        }
+        else {
+            SingletonMap.map.set(key, obj);
+        }
+    }
+}
+exports.SingletonMap = SingletonMap;
+SingletonMap.map = new Map();

package/lib/commonjs/RcsbUtils/Helpers/UrlTools.d.ts

@@ -0,0 +1,11 @@
+export declare namespace UrlTools {
+    function encodeUrlParameterList(paramList: {
+        key: string;
+        value: any;
+    }[]): void;
+    function encodeUrlParameter(key: string, value: any): void;
+    function decodeUrlParameters(): {
+        key: string;
+        value: any;
+    }[] | undefined;
+}

package/lib/commonjs/RcsbUtils/Helpers/UrlTools.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlTools = void 0;
+var UrlTools;
+(function (UrlTools) {
+    function encodeUrlParameterList(paramList) {
+        const urlParams = [];
+        paramList.filter(p => p.value).forEach(p => {
+            urlParams.push(`${p.key}=${encode(p.value)}`);
+        });
+        globalThis === null || globalThis === void 0 ? void 0 : globalThis.history.replaceState(null, "", "?" + urlParams.join("&"));
+    }
+    UrlTools.encodeUrlParameterList = encodeUrlParameterList;
+    function encodeUrlParameter(key, value) {
+        globalThis === null || globalThis === void 0 ? void 0 : globalThis.history.replaceState(null, "", "?" + (value ? `${key}=${encode(value)}` : ""));
+    }
+    UrlTools.encodeUrlParameter = encodeUrlParameter;
+    function decodeUrlParameters() {
+        var _a;
+        return (_a = parseUrlParameters()) === null || _a === void 0 ? void 0 : _a.map(param => ({ key: param.key, value: JSON.parse(decodeURIComponent(param.value)) }));
+    }
+    UrlTools.decodeUrlParameters = decodeUrlParameters;
+    function parseUrlParameters() {
+        if (globalThis.window.location.search.length === 0)
+            return;
+        return globalThis.window.location.search.substring(1)
+            .split("&")
+            .map((param) => (param.split("=")))
+            .map((param) => ({ key: param[0], value: param[1] }));
+    }
+    function encode(p) {
+        return encodeURIComponent(JSON.stringify(p));
+    }
+})(UrlTools || (exports.UrlTools = UrlTools = {}));

package/lib/commonjs/RcsbUtils/PairwiseAlignmentTools/AlignmentReference.d.ts

@@ -0,0 +1,17 @@
+import { AlignmentResponse } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+type AlignmentRefType = (number | undefined)[];
+export declare class AlignmentReference {
+    private readonly alignmentRefMap;
+    private readonly refId;
+    private readonly alignmentRefGaps;
+    private readonly memberRefList;
+    constructor(refId: string, targetId: string, alignment: AlignmentRefType, target: AlignmentRefType);
+    addAlignment(id: string, alignment: AlignmentRefType, target: AlignmentRefType): void;
+    buildAlignments(): AlignmentResponse;
+    private addRef;
+    private addEnd;
+    private addBeg;
+    private addGap;
+    private extendGap;
+}
+export {};

package/lib/commonjs/RcsbUtils/PairwiseAlignmentTools/AlignmentReference.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignmentReference = void 0;
+const lodash_1 = require("lodash");
+class AlignmentReference {
+    constructor(refId, targetId, alignment, target) {
+        this.memberRefList = [];
+        this.alignmentRefMap = (0, lodash_1.cloneDeep)(alignment);
+        this.alignmentRefGaps = findGaps(alignment);
+        if (alignment.length != target.length)
+            throw new Error("Alignment and target length error");
+        this.refId = refId;
+        this.memberRefList.push({
+            id: targetId,
+            map: alignment.map((v, n) => n),
+            ref: (0, lodash_1.cloneDeep)(alignment),
+            target
+        });
+    }
+    addAlignment(id, alignment, target) {
+        const gaps = findGaps(alignment);
+        for (const gapBeg in gaps) {
+            if (this.alignmentRefGaps[gapBeg])
+                this.extendGap(parseInt(gapBeg), gaps[gapBeg]);
+            else
+                this.addGap(parseInt(gapBeg), gaps[gapBeg]);
+        }
+        const beg = alignment.filter(a => (a && this.alignmentRefMap[0] && a < this.alignmentRefMap[0]));
+        if (beg.length > 0)
+            this.addBeg(beg);
+        const n = this.alignmentRefMap[this.alignmentRefMap.length - 1];
+        const end = alignment.filter(a => (a && n && a > n));
+        if (end.length > 0)
+            this.addEnd(end);
+        this.addRef(id, alignment, target);
+    }
+    buildAlignments() {
+        return buildAlignments(this.refId, this.alignmentRefMap, this.memberRefList);
+    }
+    addRef(id, alignment, target) {
+        const map = Array(this.alignmentRefMap.length).fill(undefined);
+        alignment.forEach((v, n) => {
+            if (typeof v === "undefined")
+                return;
+            const index = this.alignmentRefMap.findIndex(e => e === v);
+            if (index >= 0)
+                map[index] = n;
+        });
+        const gaps = findGaps(alignment);
+        for (const gapBeg in gaps) {
+            const index = this.alignmentRefMap.findIndex(v => v === parseInt(gapBeg));
+            for (let i = 1; i <= gaps[gapBeg]; i++) {
+                map[index + i] = map[index] + i;
+            }
+        }
+        this.memberRefList.push({
+            id,
+            map,
+            ref: (0, lodash_1.cloneDeep)(alignment),
+            target: (0, lodash_1.cloneDeep)(target)
+        });
+    }
+    addEnd(indexList) {
+        const last = this.alignmentRefMap.length;
+        this.alignmentRefMap.splice(last, 0, ...indexList);
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(last, 0, ...Array(indexList.length).fill(undefined));
+        });
+    }
+    addBeg(indexList) {
+        this.alignmentRefMap.splice(0, 0, ...indexList);
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(0, 0, ...Array(indexList.length).fill(undefined));
+        });
+    }
+    addGap(gapBeg, gapLength) {
+        this.alignmentRefGaps[gapBeg] = gapLength;
+        const i = this.alignmentRefMap.findIndex((v) => v === gapBeg) + 1;
+        this.alignmentRefMap.splice(i, 0, ...Array(gapLength).fill(undefined));
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(i, 0, ...Array(gapLength).fill(undefined));
+        });
+    }
+    extendGap(gapBeg, gapLength) {
+        if (!this.alignmentRefGaps[gapBeg] || this.alignmentRefGaps[gapBeg] >= gapLength)
+            return;
+        const delta = gapLength - this.alignmentRefGaps[gapBeg];
+        this.alignmentRefGaps[gapBeg] += delta;
+        const i = this.alignmentRefMap.findIndex((v) => v === gapBeg) + 1;
+        this.alignmentRefMap.splice(i, 0, ...Array(delta).fill(undefined));
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(i, 0, ...Array(delta).fill(undefined));
+        });
+    }
+}
+exports.AlignmentReference = AlignmentReference;
+function buildAlignments(refId, alignmentRefMap, alignmentMembers) {
+    const out = {};
+    out.target_alignment = [];
+    out.target_alignment.push({
+        aligned_regions: buildRegions(alignmentRefMap),
+        target_id: refId
+    });
+    alignmentMembers.forEach(am => {
+        var _a;
+        (_a = out.target_alignment) === null || _a === void 0 ? void 0 : _a.push({
+            target_id: am.id,
+            aligned_regions: buildRegions(am.map.map((v, n) => typeof v === "number" ? am.target[v] : undefined))
+        });
+    });
+    return out;
+}
+function buildRegions(alignment) {
+    const out = [];
+    let begIndex = 0;
+    let begPos = 0;
+    alignment.forEach((v, n) => {
+        if (!v) {
+            if (begIndex > 0) {
+                out.push({
+                    query_begin: begIndex,
+                    target_begin: begPos,
+                    query_end: n,
+                    target_end: alignment[n - 1]
+                });
+                begIndex = 0;
+                begPos = 0;
+            }
+        }
+        else {
+            if (begIndex == 0) {
+                begIndex = n + 1;
+                begPos = v;
+            }
+        }
+    });
+    if (begPos > 0) {
+        const n = alignment.length;
+        out.push({
+            query_begin: begIndex,
+            target_begin: begPos,
+            query_end: n,
+            target_end: alignment[n - 1]
+        });
+    }
+    return out;
+}
+function findGaps(alignment) {
+    const out = {};
+    let gapBeg = 0;
+    let gapLength = 0;
+    alignment.forEach((v, n) => {
+        if (!v) {
+            if (gapBeg == 0)
+                gapBeg = alignment[n - 1];
+            gapLength++;
+        }
+        else {
+            if (gapLength > 0) {
+                out[gapBeg] = gapLength;
+                gapBeg = 0;
+                gapLength = 0;
+            }
+        }
+    });
+    if (gapLength > 0)
+        out[gapBeg] = gapLength;
+    return out;
+}

package/lib/commonjs/RcsbUtils/PairwiseAlignmentTools/PairwiseAlignmentBuilder.d.ts

@@ -0,0 +1,37 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+export interface PairwiseAlignmentInterface {
+    querySequence: string;
+    targetSequence: string;
+    queryAlignment: string;
+    targetAlignment: string;
+    queryBegin: number;
+    queryEnd: number;
+    targetBegin: number;
+    targetEnd: number;
+    targetId: string;
+    queryId: string;
+    sequenceId: number;
+    isQueryExternal: boolean;
+    isTargetExternal: boolean;
+    pairwiseView?: boolean;
+}
+export declare class PairwiseAlignmentBuilder {
+    private querySequence;
+    private targetSequence;
+    private queryAlignment;
+    private targetAlignment;
+    private readonly queryBegin;
+    private readonly targetBegin;
+    private readonly alignmentLength;
+    private readonly targetId;
+    private readonly queryId;
+    private sequenceId;
+    private readonly isQueryExternal;
+    private readonly isTargetExternal;
+    private readonly pairwiseView;
+    constructor(paI: PairwiseAlignmentInterface);
+    getLength(): number;
+    buildReferenceAlignment(): Array<RcsbFvRowConfigInterface>;
+    buildPairwiseAlignment(): Array<RcsbFvRowConfigInterface>;
+    private addBlockTerminalTags;
+}