molstar 3.0.0-dev.6 → 3.0.0

package/lib/extensions/anvil/representation.d.ts

@@ -27,6 +27,16 @@ declare const BilayerPlanesParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type BilayerPlanesParams = typeof BilayerPlanesParams;
 export declare type BilayerPlanesProps = PD.Values<BilayerPlanesParams>;
@@ -44,6 +54,16 @@ declare const BilayerRimsParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type BilayerRimsParams = typeof BilayerRimsParams;
 export declare type BilayerRimsProps = PD.Values<BilayerRimsParams>;
@@ -62,6 +82,16 @@ export declare const MembraneOrientationParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     sectorOpacity: PD.Numeric;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;
@@ -88,6 +118,16 @@ export declare function getMembraneOrientationParams(ctx: ThemeRegistryContext,
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     sectorOpacity: PD.Numeric;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;
@@ -114,6 +154,16 @@ export declare const MembraneOrientationRepresentationProvider: StructureReprese
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     sectorOpacity: PD.Numeric;
     doubleSided: PD.BooleanParam;
     flipSided: PD.BooleanParam;

package/lib/extensions/anvil/representation.js

@@ -27,7 +27,7 @@ var SharedParams = {
     radiusFactor: PD.Numeric(1.2, { min: 0.1, max: 3.0, step: 0.01 }, { description: 'Scale the radius of the membrane layer' })
 };
 var BilayerPlanesParams = __assign(__assign(__assign({}, Mesh.Params), SharedParams), { sectorOpacity: PD.Numeric(0.5, { min: 0, max: 1, step: 0.01 }) });
-var BilayerRimsParams = __assign(__assign(__assign({}, Lines.Params), SharedParams), { lineSizeAttenuation: PD.Boolean(true), linesSize: PD.Numeric(0.3, { min: 0.01, max: 50, step: 0.01 }), dashedLines: PD.Boolean(true) });
+var BilayerRimsParams = __assign(__assign(__assign({}, Lines.Params), SharedParams), { lineSizeAttenuation: PD.Boolean(false), linesSize: PD.Numeric(0.5, { min: 0.01, max: 50, step: 0.01 }), dashedLines: PD.Boolean(false) });
 var MembraneOrientationVisuals = {
     'bilayer-planes': function (ctx, getParams) { return ShapeRepresentation(getBilayerPlanes, Mesh.Utils, { modifyState: function (s) { return (__assign(__assign({}, s), { markerActions: MarkerActions.Highlighting })); }, modifyProps: function (p) { return (__assign(__assign({}, p), { alpha: p.sectorOpacity, ignoreLight: true, doubleSided: false })); } }); },
     'bilayer-rims': function (ctx, getParams) { return ShapeRepresentation(getBilayerRims, Lines.Utils, { modifyState: function (s) { return (__assign(__assign({}, s), { markerActions: MarkerActions.Highlighting })); } }); }

package/lib/extensions/cellpack/representation.d.ts

@@ -52,6 +52,16 @@ export declare const MBParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type MBParams = typeof MBParams;
 export declare type UnitcellProps = PD.Values<MBParams>;

package/lib/extensions/dnatco/confal-pyramids/representation.d.ts

@@ -26,6 +26,16 @@ export declare const ConfalPyramidsParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type ConfalPyramidsParams = typeof ConfalPyramidsParams;
 export declare function getConfalPyramidsParams(ctx: ThemeRegistryContext, structure: Structure): {
@@ -45,6 +55,16 @@ export declare function getConfalPyramidsParams(ctx: ThemeRegistryContext, struc
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type ConfalPyramidsRepresentation = StructureRepresentation<ConfalPyramidsParams>;
 export declare function ConfalPyramidsRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, ConfalPyramidsParams>): ConfalPyramidsRepresentation;
@@ -65,4 +85,14 @@ export declare const ConfalPyramidsRepresentationProvider: StructureRepresentati
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 }, "confal-pyramids">;

package/lib/extensions/geo-export/mesh-exporter.js

@@ -14,7 +14,7 @@ import { addCylinder } from '../../mol-geo/geometry/mesh/builder/cylinder';
 import { sizeDataFactor } from '../../mol-geo/geometry/size-data';
 import { Vec3 } from '../../mol-math/linear-algebra';
 import { Color } from '../../mol-util/color/color';
-import { decodeFloatRGB } from '../../mol-util/float-packing';
+import { unpackRGBToInt } from '../../mol-util/number-packing';
 import { readAlphaTexture, readTexture } from '../../mol-gl/compute/util';
 var GeoExportName = 'geo-export';
 // avoiding namespace lookup improved performance in Chrome (Aug 2020)
@@ -26,7 +26,7 @@ var MeshExporter = /** @class */ (function () {
         var r = tSize.array[i * 3];
         var g = tSize.array[i * 3 + 1];
         var b = tSize.array[i * 3 + 2];
-        return decodeFloatRGB(r, g, b) / sizeDataFactor;
+        return unpackRGBToInt(r, g, b) / sizeDataFactor;
     };
     MeshExporter.getSize = function (values, instanceIndex, group) {
         var tSize = values.tSize.ref.value;
@@ -54,9 +54,9 @@ var MeshExporter = /** @class */ (function () {
         var g = groups[i4 + 1];
         var b = groups[i4 + 2];
         if (groups instanceof Float32Array) {
-            return decodeFloatRGB(r * 255 + 0.5, g * 255 + 0.5, b * 255 + 0.5);
+            return unpackRGBToInt(r * 255 + 0.5, g * 255 + 0.5, b * 255 + 0.5);
         }
-        return decodeFloatRGB(r, g, b);
+        return unpackRGBToInt(r, g, b);
     };
     MeshExporter.getInterpolatedColors = function (webgl, input) {
         var values = input.values, vertexCount = input.vertexCount, vertices = input.vertices, colorType = input.colorType, stride = input.stride;

package/lib/extensions/model-export/export.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { PluginContext } from '../../mol-plugin/context';
+export declare function exportHierarchy(plugin: PluginContext, options?: {
+    format?: 'cif' | 'bcif';
+}): Promise<void>;

package/lib/extensions/model-export/export.js

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { __awaiter, __generator } from "tslib";
+import { utf8ByteCount, utf8Write } from '../../mol-io/common/utf8';
+import { to_mmCIF, Unit } from '../../mol-model/structure';
+import { Task } from '../../mol-task';
+import { getFormattedTime } from '../../mol-util/date';
+import { download } from '../../mol-util/download';
+import { zip } from '../../mol-util/zip/zip';
+export function exportHierarchy(plugin, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, plugin.runTask(_exportHierarchy(plugin, options), { useOverlay: true })];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    e_1 = _a.sent();
+                    console.error(e_1);
+                    plugin.log.error("Model export failed. See console for details.");
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function _exportHierarchy(plugin, options) {
+    var _this = this;
+    return Task.create('Export', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+        var format, structures, files, entryMap, _i, structures_1, _s, s, name_1, zipData, _a, files_1, _b, fn, data, bytes, buffer;
+        var _c, _d, _e, _f, _g, _h, _j, _k;
+        return __generator(this, function (_l) {
+            switch (_l.label) {
+                case 0: return [4 /*yield*/, ctx.update({ message: 'Exporting...', isIndeterminate: true, canAbort: false })];
+                case 1:
+                    _l.sent();
+                    format = (_c = options === null || options === void 0 ? void 0 : options.format) !== null && _c !== void 0 ? _c : 'cif';
+                    structures = plugin.managers.structure.hierarchy.current.structures;
+                    files = [];
+                    entryMap = new Map();
+                    _i = 0, structures_1 = structures;
+                    _l.label = 2;
+                case 2:
+                    if (!(_i < structures_1.length)) return [3 /*break*/, 7];
+                    _s = structures_1[_i];
+                    s = (_f = (_e = (_d = _s.transform) === null || _d === void 0 ? void 0 : _d.cell.obj) === null || _e === void 0 ? void 0 : _e.data) !== null && _f !== void 0 ? _f : (_g = _s.cell.obj) === null || _g === void 0 ? void 0 : _g.data;
+                    if (!s)
+                        return [3 /*break*/, 6];
+                    if (s.models.length > 1) {
+                        plugin.log.warn("[Export] Skipping ".concat((_h = _s.cell.obj) === null || _h === void 0 ? void 0 : _h.label, ": Multimodel exports not supported."));
+                        return [3 /*break*/, 6];
+                    }
+                    if (s.units.some(function (u) { return !Unit.isAtomic(u); })) {
+                        plugin.log.warn("[Export] Skipping ".concat((_j = _s.cell.obj) === null || _j === void 0 ? void 0 : _j.label, ": Non-atomic model exports not supported."));
+                        return [3 /*break*/, 6];
+                    }
+                    name_1 = entryMap.has(s.model.entryId)
+                        ? "".concat(s.model.entryId, "_").concat(entryMap.get(s.model.entryId) + 1, ".").concat(format)
+                        : "".concat(s.model.entryId, ".").concat(format);
+                    entryMap.set(s.model.entryId, ((_k = entryMap.get(s.model.entryId)) !== null && _k !== void 0 ? _k : 0) + 1);
+                    return [4 /*yield*/, ctx.update({ message: "Exporting ".concat(s.model.entryId, "..."), isIndeterminate: true, canAbort: false })];
+                case 3:
+                    _l.sent();
+                    if (!(s.elementCount > 100000)) return [3 /*break*/, 5];
+                    // Give UI chance to update, only needed for larger structures.
+                    return [4 /*yield*/, new Promise(function (res) { return setTimeout(res, 50); })];
+                case 4:
+                    // Give UI chance to update, only needed for larger structures.
+                    _l.sent();
+                    _l.label = 5;
+                case 5:
+                    try {
+                        files.push([name_1, to_mmCIF(s.model.entryId, s, format === 'bcif', { copyAllCategories: true })]);
+                    }
+                    catch (e) {
+                        if (format === 'cif' && s.elementCount > 2000000) {
+                            plugin.log.warn("[Export] The structure might be too big to be exported as Text CIF, consider using the BinaryCIF format instead.");
+                        }
+                        throw e;
+                    }
+                    _l.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 7:
+                    if (!(files.length === 1)) return [3 /*break*/, 8];
+                    download(new Blob([files[0][1]]), files[0][0]);
+                    return [3 /*break*/, 11];
+                case 8:
+                    if (!(files.length > 1)) return [3 /*break*/, 11];
+                    zipData = {};
+                    for (_a = 0, files_1 = files; _a < files_1.length; _a++) {
+                        _b = files_1[_a], fn = _b[0], data = _b[1];
+                        if (data instanceof Uint8Array) {
+                            zipData[fn] = data;
+                        }
+                        else {
+                            bytes = new Uint8Array(utf8ByteCount(data));
+                            utf8Write(bytes, 0, data);
+                            zipData[fn] = bytes;
+                        }
+                    }
+                    return [4 /*yield*/, ctx.update({ message: "Compressing Data...", isIndeterminate: true, canAbort: false })];
+                case 9:
+                    _l.sent();
+                    return [4 /*yield*/, zip(ctx, zipData)];
+                case 10:
+                    buffer = _l.sent();
+                    download(new Blob([new Uint8Array(buffer, 0, buffer.byteLength)]), "structures_".concat(getFormattedTime(), ".zip"));
+                    _l.label = 11;
+                case 11:
+                    plugin.log.info("[Export] Done.");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+}
+//# sourceMappingURL=export.js.map

package/lib/extensions/model-export/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { PluginBehavior } from '../../mol-plugin/behavior/behavior';
+export declare const ModelExport: import("../../mol-state/transformer").StateTransformer<PluginBehavior.Category, PluginBehavior.Behavior, {}>;

package/lib/extensions/model-export/index.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { __extends } from "tslib";
+import { PluginBehavior } from '../../mol-plugin/behavior/behavior';
+import { ModelExportUI } from './ui';
+export var ModelExport = PluginBehavior.create({
+    name: 'extension-model-export',
+    category: 'misc',
+    display: {
+        name: 'Model Export'
+    },
+    ctor: /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.register = function () {
+            this.ctx.customStructureControls.set('model-export', ModelExportUI);
+        };
+        class_1.prototype.update = function () {
+            return false;
+        };
+        class_1.prototype.unregister = function () {
+            this.ctx.customStructureControls.delete('model-export');
+        };
+        return class_1;
+    }(PluginBehavior.Handler)),
+    params: function () { return ({}); }
+});
+//# sourceMappingURL=index.js.map

package/lib/extensions/model-export/ui.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+/// <reference types="react" />
+import { CollapsableControls, CollapsableState } from '../../mol-plugin-ui/base';
+export declare class ModelExportUI extends CollapsableControls<{}, {}> {
+    protected defaultState(): CollapsableState;
+    protected renderControls(): JSX.Element | null;
+}

package/lib/extensions/model-export/ui.js

@@ -0,0 +1,74 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { useState } from 'react';
+import { CollapsableControls } from '../../mol-plugin-ui/base';
+import { Button } from '../../mol-plugin-ui/controls/common';
+import { GetAppSvg } from '../../mol-plugin-ui/controls/icons';
+import { ParameterControls } from '../../mol-plugin-ui/controls/parameters';
+import { useBehavior } from '../../mol-plugin-ui/hooks/use-behavior';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { exportHierarchy } from './export';
+var ModelExportUI = /** @class */ (function (_super) {
+    __extends(ModelExportUI, _super);
+    function ModelExportUI() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ModelExportUI.prototype.defaultState = function () {
+        return {
+            header: 'Export Models',
+            isCollapsed: true,
+            brand: { accent: 'cyan', svg: GetAppSvg }
+        };
+    };
+    ModelExportUI.prototype.renderControls = function () {
+        return _jsx(ExportControls, { plugin: this.plugin }, void 0);
+    };
+    return ModelExportUI;
+}(CollapsableControls));
+export { ModelExportUI };
+var Params = {
+    format: PD.Select('cif', [['cif', 'mmCIF'], ['bcif', 'Binary mmCIF']])
+};
+var DefaultParams = PD.getDefaultValues(Params);
+function ExportControls(_a) {
+    var _this = this;
+    var plugin = _a.plugin;
+    var _b = useState(DefaultParams), params = _b[0], setParams = _b[1];
+    var _c = useState(false), exporting = _c[0], setExporting = _c[1];
+    useBehavior(plugin.managers.structure.hierarchy.behaviors.selection); // triggers UI update
+    var isBusy = useBehavior(plugin.behaviors.state.isBusy);
+    var hierarchy = plugin.managers.structure.hierarchy.current;
+    var label = 'Nothing to Export';
+    if (hierarchy.structures.length === 1) {
+        label = 'Export';
+    }
+    if (hierarchy.structures.length > 1) {
+        label = 'Export (as ZIP)';
+    }
+    var onExport = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setExporting(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 3, 4]);
+                    return [4 /*yield*/, exportHierarchy(plugin, { format: params.format })];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    setExporting(false);
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    return _jsxs(_Fragment, { children: [_jsx(ParameterControls, { params: Params, values: params, onChangeValues: setParams, isDisabled: isBusy || exporting }, void 0), _jsx(Button, __assign({ onClick: onExport, style: { marginTop: 1 }, disabled: isBusy || hierarchy.structures.length === 0 || exporting, commit: hierarchy.structures.length ? 'on' : 'off' }, { children: label }), void 0)] }, void 0);
+}
+//# sourceMappingURL=ui.js.map

package/lib/extensions/mp4-export/encoder.js

@@ -64,7 +64,7 @@ export function encodeMp4Animation(plugin, ctx, params) {
                     _d.label = 6;
                 case 6:
                     if (!(i <= N)) return [3 /*break*/, 10];
-                    return [4 /*yield*/, loop.tick(i * dt, { isSynchronous: true, manualDraw: true })];
+                    return [4 /*yield*/, loop.tick(i * dt, { isSynchronous: true, animation: { currentFrame: i, frameCount: N }, manualDraw: true })];
                 case 7:
                     _d.sent();
                     image = params.pass.getImageData(width, height, normalizedViewport);

package/lib/extensions/rcsb/assembly-symmetry/behavior.d.ts

@@ -33,6 +33,10 @@ declare const AssemblySymmetry3D: StateTransformer<PluginStateObject.Molecule.St
         roughness: number;
         bumpiness: number;
     }>;
+    clip: PD.Normalize<{
+        variant: any;
+        objects: any;
+    }>;
     axesColor: PD.NamedParams<PD.Normalize<{
         colorValue: any;
     }>, "uniform"> | PD.NamedParams<PD.Normalize<unknown>, "byOrder">;
@@ -41,9 +45,9 @@ export declare const AssemblySymmetryPresetParams: {
     ignoreHydrogens: PD.Base<boolean | undefined>;
     quality: PD.Base<"auto" | "medium" | "high" | "low" | "custom" | "highest" | "higher" | "lower" | "lowest" | undefined>;
     theme: PD.Base<PD.Normalize<{
-        globalName: "uniform" | "occupancy" | "element-index" | "element-symbol" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "entity-source" | "illustrative" | "hydrophobicity" | "model-index" | "operator-hkl" | "partial-charge" | "atom-id" | "entity-id" | undefined;
+        globalName: "uniform" | "occupancy" | "element-index" | "element-symbol" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "entity-source" | "entity-id" | "illustrative" | "hydrophobicity" | "model-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | undefined;
         carbonColor: "element-symbol" | "chain-id" | "operator-name" | undefined;
-        symmetryColor: "uniform" | "occupancy" | "element-index" | "element-symbol" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "entity-source" | "illustrative" | "hydrophobicity" | "model-index" | "operator-hkl" | "partial-charge" | "atom-id" | "entity-id" | undefined;
+        symmetryColor: "uniform" | "occupancy" | "element-index" | "element-symbol" | "shape-group" | "uncertainty" | "carbohydrate-symbol" | "chain-id" | "operator-name" | "molecule-type" | "polymer-id" | "polymer-index" | "residue-name" | "secondary-structure" | "sequence-id" | "unit-index" | "entity-source" | "entity-id" | "illustrative" | "hydrophobicity" | "model-index" | "operator-hkl" | "partial-charge" | "atom-id" | "volume-value" | undefined;
         focus: PD.Normalize<{
             name: any;
             params: any;

package/lib/extensions/rcsb/assembly-symmetry/representation.d.ts

@@ -25,6 +25,16 @@ export declare const AssemblySymmetryParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
     axesColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
         colorValue: Color;
     }>, "uniform"> | PD.NamedParams<PD.Normalize<unknown>, "byOrder">>;

package/lib/extensions/rcsb/graphql/types.d.ts

@@ -10844,11 +10844,11 @@ export declare type RcsbUniprotAlignments = {
 };
 export declare type RcsbUniprotAlignmentsCoreEntityAlignments = {
     /** Aligned region */
-    readonly aligned_regions?: Maybe<ReadonlyArray<Maybe<CoreEntityAlignmentsAlignedRegions>>>;
+    readonly aligned_regions: ReadonlyArray<Maybe<CoreEntityAlignmentsAlignedRegions>>;
     /** core_entity identifiers */
     readonly core_entity_identifiers?: Maybe<CoreEntityAlignmentsCoreEntityIdentifiers>;
     /** Alignment scores */
-    readonly scores?: Maybe<CoreEntityAlignmentsScores>;
+    readonly scores: CoreEntityAlignmentsScores;
 };
 export declare type RcsbUniprotAnnotation = {
     /** An identifier for the annotation. */

package/lib/extensions/rcsb/validation-report/representation.d.ts

@@ -40,6 +40,16 @@ export declare const IntraUnitClashParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type IntraUnitClashParams = typeof IntraUnitClashParams;
 export declare function IntraUnitClashVisual(materialId: number): UnitsVisual<IntraUnitClashParams>;
@@ -72,6 +82,16 @@ export declare const InterUnitClashParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type InterUnitClashParams = typeof InterUnitClashParams;
 export declare function InterUnitClashVisual(materialId: number): ComplexVisual<InterUnitClashParams>;
@@ -105,6 +125,16 @@ export declare const ClashesParams: {
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type ClashesParams = typeof ClashesParams;
 export declare function getClashesParams(ctx: ThemeRegistryContext, structure: Structure): {
@@ -137,6 +167,16 @@ export declare function getClashesParams(ctx: ThemeRegistryContext, structure: S
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 };
 export declare type ClashesRepresentation = StructureRepresentation<ClashesParams>;
 export declare function ClashesRepresentation(ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, ClashesParams>): ClashesRepresentation;
@@ -170,4 +210,14 @@ export declare const ClashesRepresentationProvider: StructureRepresentationProvi
         roughness: number;
         bumpiness: number;
     }>>;
+    clip: PD.Group<PD.Normalize<{
+        variant: import("../../../mol-util/clip").Clip.Variant;
+        objects: PD.Normalize<{
+            type: any;
+            invert: any;
+            position: any;
+            rotation: any;
+            scale: any;
+        }>[];
+    }>>;
 }, ValidationReport.Tag.Clashes>;