moved helpers.d.ts to mol-util/type-helpers.ts and import explicitly

src/helpers.d.ts

@@ -1,22 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-declare module Helpers {
-    export type Mutable<T> = {
-        -readonly [P in keyof T]: T[P]
-    }
-    export type TypedIntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
-    export type TypedFloatArray = Float32Array | Float64Array
-
-    export type TypedArray = TypedIntArray | TypedFloatArray
-    export type NumberArray = TypedArray | number[]
-    export type UintArray = Uint8Array | Uint16Array | Uint32Array | number[]
-    export type ValueOf<T> = T[keyof T]
-    export type ArrayCtor<T> = { new(size: number): { [i: number]: T, length: number } }
-    /** assignable ArrayLike version */
-    export type ArrayLike<T> =  { [i: number]: T, length: number }
-}

src/mol-data/util/array.ts

@@ -5,6 +5,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+import { ArrayCtor } from 'mol-util/type-helpers';
+
 export function arrayFind<T>(array: ArrayLike<T>, f: (v: T) => boolean): T | undefined {
     for (let i = 0, _i = array.length; i < _i; i++) {
         if (f(array[i])) return array[i];
@@ -25,7 +27,7 @@ export function iterableToArray<T>(it: IterableIterator<T>): T[] {
 }
 
 /** Fills the array so that array[0] = start and array[array.length - 1] = end */
-export function createRangeArray(start: number, end: number, ctor?: Helpers.ArrayCtor<number>) {
+export function createRangeArray(start: number, end: number, ctor?: ArrayCtor<number>) {
     const len = end - start + 1;
     const array = ctor ? new ctor(len) : new Int32Array(len);
     for (let i = 0; i < len; i++) {
@@ -42,7 +44,7 @@ export function arrayPickIndices<T>(array: ArrayLike<T>, indices: ArrayLike<numb
     return ret;
 }
 
-export function arrayGetCtor<T>(data: ArrayLike<T>): Helpers.ArrayCtor<T> {
+export function arrayGetCtor<T>(data: ArrayLike<T>): ArrayCtor<T> {
     const ret = (data as any).constructor;
     if (!ret) throw new Error('data does not define a constructor and it should');
     return ret;

src/mol-data/util/buckets.ts

@@ -5,6 +5,7 @@
  */
 
 import { sort, arraySwap } from './sort';
+import { AssignableArrayLike } from 'mol-util/type-helpers';
 
 type Bucket = {
     key: any,
@@ -14,7 +15,7 @@ type Bucket = {
 
 function sortAsc(bs: Bucket[], i: number, j: number) { return bs[i].key < bs[j].key ? -1 : 1; }
 
-function _makeBuckets(indices: Helpers.ArrayLike<number>,
+function _makeBuckets(indices: AssignableArrayLike<number>,
     getKey: (i: number) => any, sortBuckets: boolean, start: number, end: number) {
 
     const buckets = new Map<any, Bucket>();
@@ -95,7 +96,7 @@ export interface MakeBucketsOptions<K> {
  * Returns the offsets of buckets. So that [offsets[i], offsets[i + 1]) determines the range.
  */
 export function makeBuckets<K extends string | number>(
-    indices: Helpers.ArrayLike<number>, getKey: (i: number) => K, options?: MakeBucketsOptions<K>): ArrayLike<number> {
+    indices: AssignableArrayLike<number>, getKey: (i: number) => K, options?: MakeBucketsOptions<K>): ArrayLike<number> {
     const s = (options && options.start) || 0;
     const e = (options && options.end) || indices.length;
     if (e - s <= 0) throw new Error('Can only bucket non-empty collections.');

src/mol-geo/geometry/geometry.ts

@@ -20,6 +20,7 @@ import { arrayMax } from 'mol-util/array';
 import { TransformData } from './transform-data';
 import { Theme } from 'mol-theme/theme';
 import { RenderObjectValuesType } from 'mol-gl/render-object';
+import { ValueOf } from 'mol-util/type-helpers';
 
 export type GeometryKindType = {
     'mesh': Mesh,
@@ -38,7 +39,7 @@ export type GeometryKindParams = {
     'direct-volume': DirectVolume.Params,
 }
 export type GeometryKind = keyof GeometryKindType
-export type Geometry = Helpers.ValueOf<GeometryKindType>
+export type Geometry = ValueOf<GeometryKindType>
 
 export interface GeometryUtils<G extends Geometry, P extends PD.Params = GeometryKindParams[G['kind']], V = RenderObjectValuesType[G['kind']]> {
     Params: P

src/mol-geo/util.ts

@@ -5,8 +5,9 @@
  */
 
 import { Vec3, Mat4, Mat3 } from 'mol-math/linear-algebra'
+import { NumberArray } from 'mol-util/type-helpers';
 
-export function normalizeVec3Array<T extends Helpers.NumberArray> (a: T) {
+export function normalizeVec3Array<T extends NumberArray> (a: T) {
     const n = a.length
     for (let i = 0; i < n; i += 3) {
         const x = a[ i ]
@@ -28,7 +29,7 @@ export function getNormalMatrix(out: Mat3, t: Mat4) {
 
 const tmpV3 = Vec3.zero()
 
-export function transformPositionArray (t: Mat4, array: Helpers.NumberArray, offset: number, count: number) {
+export function transformPositionArray (t: Mat4, array: NumberArray, offset: number, count: number) {
     for (let i = 0, il = count * 3; i < il; i += 3) {
         Vec3.fromArray(tmpV3, array, offset + i)
         Vec3.transformMat4(tmpV3, tmpV3, t)
@@ -36,7 +37,7 @@ export function transformPositionArray (t: Mat4, array: Helpers.NumberArray, off
     }
 }
 
-export function transformDirectionArray (n: Mat3, array: Helpers.NumberArray, offset: number, count: number) {
+export function transformDirectionArray (n: Mat3, array: NumberArray, offset: number, count: number) {
     for (let i = 0, il = count * 3; i < il; i += 3) {
         Vec3.fromArray(tmpV3, array, offset + i)
         Vec3.transformMat3(tmpV3, tmpV3, n)
@@ -44,13 +45,13 @@ export function transformDirectionArray (n: Mat3, array: Helpers.NumberArray, of
     }
 }
 
-export function setArrayZero(array: Helpers.NumberArray) {
+export function setArrayZero(array: NumberArray) {
     const n = array.length
     for (let i = 0; i < n; ++i) array[i] = 0
 }
 
 /** iterate over the entire buffer and apply the radius to each vertex */
-export function appplyRadius(vertices: Helpers.NumberArray, radius: number) {
+export function appplyRadius(vertices: NumberArray, radius: number) {
     const v = Vec3.zero()
     const n = vertices.length
     for (let i = 0; i < n; i += 3) {
@@ -65,7 +66,7 @@ export function appplyRadius(vertices: Helpers.NumberArray, radius: number) {
  * indexed vertex normals weighted by triangle areas http://www.iquilezles.org/www/articles/normals/normals.htm
  * normal array must contain only zeros
  */
-export function computeIndexedVertexNormals<T extends Helpers.NumberArray> (vertices: Helpers.NumberArray, indices: Helpers.NumberArray, normals: T) {
+export function computeIndexedVertexNormals<T extends NumberArray> (vertices: NumberArray, indices: NumberArray, normals: T) {
     const a = Vec3.zero()
     const b = Vec3.zero()
     const c = Vec3.zero()
@@ -103,7 +104,7 @@ export function computeIndexedVertexNormals<T extends Helpers.NumberArray> (vert
 }
 
 /** vertex normals for unindexed triangle soup, normal array must contain only zeros */
-export function computeVertexNormals<T extends Helpers.NumberArray> (vertices: Helpers.NumberArray, normals: T) {
+export function computeVertexNormals<T extends NumberArray> (vertices: NumberArray, normals: T) {
     setArrayZero(normals)
 
     const a = Vec3.zero()

src/mol-gl/webgl/buffer.ts

@@ -8,6 +8,7 @@ import { WebGLContext } from './context'
 import { ValueCell } from 'mol-util';
 import { RenderableSchema } from '../renderable/schema';
 import { idFactory } from 'mol-util/id-factory';
+import { ValueOf } from 'mol-util/type-helpers';
 
 const getNextBufferId = idFactory()
 
@@ -24,7 +25,7 @@ export type DataTypeArrayType = {
     'int32': Int32Array
     'float32': Float32Array
 }
-export type ArrayType = Helpers.ValueOf<DataTypeArrayType>
+export type ArrayType = ValueOf<DataTypeArrayType>
 export type ArrayKind = keyof DataTypeArrayType
 
 export type BufferItemSize = 1 | 2 | 3 | 4 | 16

src/mol-gl/webgl/render-target.ts

@@ -10,6 +10,7 @@ import { createTexture, Texture } from './texture';
 import { createFramebuffer } from './framebuffer';
 import { createRenderbuffer } from './renderbuffer';
 import { TextureImage } from '../renderable/util';
+import { Mutable } from 'mol-util/type-helpers';
 
 const getNextRenderTargetId = idFactory()
 
@@ -32,7 +33,7 @@ export interface RenderTarget {
 export function createRenderTarget (ctx: WebGLContext, _width: number, _height: number): RenderTarget {
     const { gl } = ctx
 
-    const image: Helpers.Mutable<TextureImage<Uint8Array>> = {
+    const image: Mutable<TextureImage<Uint8Array>> = {
         array: new Uint8Array(_width * _height * 4),
         width: _width,
         height: _height

src/mol-gl/webgl/texture.ts

@@ -11,6 +11,7 @@ import { RenderableSchema } from '../renderable/schema';
 import { idFactory } from 'mol-util/id-factory';
 import { Framebuffer } from './framebuffer';
 import { isWebGL2 } from './compat';
+import { ValueOf } from 'mol-util/type-helpers';
 
 const getNextTextureId = idFactory()
 
@@ -21,7 +22,7 @@ export type TextureKindValue = {
     'volume-float32': TextureVolume<Float32Array>
     'texture': Texture
 }
-export type TextureValueType = Helpers.ValueOf<TextureKindValue>
+export type TextureValueType = ValueOf<TextureKindValue>
 export type TextureKind = keyof TextureKindValue
 export type TextureType = 'ubyte' | 'float'
 export type TextureFormat = 'alpha' | 'rgb' | 'rgba'

src/mol-io/common/binary-cif/array-encoder.ts

@@ -10,6 +10,7 @@
 import { ChunkedArray } from 'mol-data/util'
 import { Encoding, EncodedData } from './encoding'
 import { classifyIntArray } from './classifier';
+import { TypedIntArray, TypedFloatArray } from 'mol-util/type-helpers';
 
 export interface ArrayEncoder {
     and(f: ArrayEncoding.Provider): ArrayEncoder,
@@ -119,7 +120,7 @@ export namespace ArrayEncoding {
         [Encoding.FloatDataType.Float64]: 8
     }
 
-    export function byteArray(data: Encoding.TypedFloatArray | Encoding.TypedIntArray) {
+    export function byteArray(data: TypedFloatArray | TypedIntArray) {
         const type = Encoding.getDataType(data);
 
         if (type === Encoding.IntDataType.Int8) return int8(data as Int8Array);
@@ -137,7 +138,7 @@ export namespace ArrayEncoding {
         };
     }
 
-    function _fixedPoint(data: Encoding.TypedFloatArray, factor: number): Result {
+    function _fixedPoint(data: TypedFloatArray, factor: number): Result {
         const srcType = Encoding.getDataType(data) as Encoding.FloatDataType;
         const result = new Int32Array(data.length);
         for (let i = 0, n = data.length; i < n; i++) {
@@ -148,9 +149,9 @@ export namespace ArrayEncoding {
             data: result
         };
     }
-    export function fixedPoint(factor: number): Provider { return data => _fixedPoint(data as Encoding.TypedFloatArray, factor); }
+    export function fixedPoint(factor: number): Provider { return data => _fixedPoint(data as TypedFloatArray, factor); }
 
-    function _intervalQuantizaiton(data: Encoding.TypedFloatArray, min: number, max: number, numSteps: number, arrayType: new (size: number) => Encoding.TypedIntArray): Result {
+    function _intervalQuantizaiton(data: TypedFloatArray, min: number, max: number, numSteps: number, arrayType: new (size: number) => TypedIntArray): Result {
         const srcType = Encoding.getDataType(data) as Encoding.FloatDataType;
         if (!data.length) {
             return {
@@ -180,11 +181,11 @@ export namespace ArrayEncoding {
             data: output
         };
     }
-    export function intervalQuantizaiton(min: number, max: number, numSteps: number, arrayType: new (size: number) => Encoding.TypedIntArray = Int32Array): Provider {
-        return data => _intervalQuantizaiton(data as Encoding.TypedFloatArray, min, max, numSteps, arrayType);
+    export function intervalQuantizaiton(min: number, max: number, numSteps: number, arrayType: new (size: number) => TypedIntArray = Int32Array): Provider {
+        return data => _intervalQuantizaiton(data as TypedFloatArray, min, max, numSteps, arrayType);
     }
 
-    export function runLength(data: Encoding.TypedIntArray): Result {
+    export function runLength(data: TypedIntArray): Result {
         let srcType = Encoding.getDataType(data) as Encoding.IntDataType;
         if (srcType === void 0) {
             data = new Int32Array(data);

src/mol-io/common/binary-cif/encoding.ts

@@ -5,6 +5,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+import { TypedIntArray, TypedFloatArray } from 'mol-util/type-helpers';
+
 export const VERSION = '0.3.0';
 
 export type Encoding =
@@ -71,9 +73,6 @@ export namespace Encoding {
 
     export type DataType = IntDataType | FloatDataType
 
-    export type TypedIntArray = Helpers.TypedIntArray
-    export type TypedFloatArray = Helpers.TypedFloatArray
-
     export function getDataType(data: TypedIntArray | TypedFloatArray): DataType {
         let srcType: DataType;
         if (data instanceof Int8Array) srcType = Encoding.IntDataType.Int8;

src/mol-io/writer/cif/encoder/binary.ts

@@ -15,6 +15,7 @@ import { Field, Category, Encoder } from '../encoder'
 import Writer from '../../writer'
 import { getIncludedFields, getCategoryInstanceData, CategoryInstanceData } from './util';
 import { classifyIntArray, classifyFloatArray } from '../../../common/binary-cif/classifier';
+import { ArrayCtor } from 'mol-util/type-helpers';
 
 export interface EncodingProvider {
     get(category: string, field: string): ArrayEncoder | undefined;
@@ -96,7 +97,7 @@ export default class BinaryEncoder implements Encoder<Uint8Array> {
     }
 }
 
-function getArrayCtor(field: Field, format: Field.Format | undefined): Helpers.ArrayCtor<string | number> {
+function getArrayCtor(field: Field, format: Field.Format | undefined): ArrayCtor<string | number> {
     if (format && format.typedArray) return format.typedArray;
     if (field.defaultFormat && field.defaultFormat.typedArray) return field.defaultFormat.typedArray;
     if (field.type === Field.Type.Str) return Array;
@@ -157,7 +158,7 @@ function encodeField(categoryName: string, field: Field, data: CategoryInstanceD
     };
 }
 
-function getFieldData(field: Field<any, any>, arrayCtor: Helpers.ArrayCtor<string | number>, totalCount: number, data: CategoryInstanceData['source']) {
+function getFieldData(field: Field<any, any>, arrayCtor: ArrayCtor<string | number>, totalCount: number, data: CategoryInstanceData['source']) {
     const isStr = field.type === Field.Type.Str;
     const array = new arrayCtor(totalCount);
     const mask = new Uint8Array(totalCount);

src/mol-math/geometry/distance-transform.ts

@@ -4,10 +4,12 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
+import { NumberArray } from 'mol-util/type-helpers';
+
 /**
  * 2D Euclidean distance transform by Felzenszwalb & Huttenlocher https://cs.brown.edu/~pff/papers/dt-final.pdf
  */
-export function edt(data: Helpers.NumberArray, width: number, height: number, f: Helpers.NumberArray, d: Helpers.NumberArray, v: Helpers.NumberArray, z: Helpers.NumberArray) {
+export function edt(data: NumberArray, width: number, height: number, f: NumberArray, d: NumberArray, v: NumberArray, z: NumberArray) {
     for (let x = 0; x < width; x++) {
         for (let y = 0; y < height; y++) {
             f[y] = data[y * width + x]
@@ -31,7 +33,7 @@ export function edt(data: Helpers.NumberArray, width: number, height: number, f:
 /**
  * 1D squared distance transform
  */
-function edt1d(f: Helpers.NumberArray, d: Helpers.NumberArray, v: Helpers.NumberArray, z: Helpers.NumberArray, n: number) {
+function edt1d(f: NumberArray, d: NumberArray, v: NumberArray, z: NumberArray, n: number) {
     v[0] = 0
     z[0] = Number.MIN_SAFE_INTEGER
     z[1] = Number.MAX_SAFE_INTEGER

src/mol-math/geometry/primitives/sphere3d.ts

@@ -8,6 +8,7 @@
 import { Vec3, Mat4, EPSILON } from '../../linear-algebra'
 import { PositionData } from '../common'
 import { OrderedSet } from 'mol-data/int';
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Sphere3D { center: Vec3, radius: number }
 
@@ -64,12 +65,12 @@ namespace Sphere3D {
         return out
     }
 
-    export function toArray(s: Sphere3D, out: Helpers.NumberArray, offset: number) {
+    export function toArray(s: Sphere3D, out: NumberArray, offset: number) {
         Vec3.toArray(s.center, out, offset)
         out[offset + 3] = s.radius
     }
 
-    export function fromArray(out: Sphere3D, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(out: Sphere3D, array: NumberArray, offset: number) {
         Vec3.fromArray(out.center, array, offset)
         out.radius = array[offset + 3]
         return out

src/mol-math/linear-algebra/3d/mat3.ts

@@ -18,6 +18,7 @@
  */
 
 import { Mat4 } from '../3d'
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Mat3 extends Array<number> { [d: number]: number, '@type': 'mat3', length: 9 }
 
@@ -56,7 +57,7 @@ namespace Mat3 {
         return mat;
     }
 
-    export function toArray(a: Mat3, out: Helpers.NumberArray, offset: number) {
+    export function toArray(a: Mat3, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
         out[offset + 2] = a[2];
@@ -68,7 +69,7 @@ namespace Mat3 {
         out[offset + 8] = a[8];
     }
 
-    export function fromArray(a: Mat3, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(a: Mat3, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         a[2] = array[offset + 2]

src/mol-math/linear-algebra/3d/mat4.ts

@@ -21,6 +21,7 @@ import { EPSILON, equalEps } from './common'
 import Vec3 from './vec3';
 import Quat from './quat';
 import { degToRad } from '../../misc';
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Mat4 extends Array<number> { [d: number]: number, '@type': 'mat4', length: 16 }
 interface ReadonlyMat4 extends Array<number> { readonly [d: number]: number, '@type': 'mat4', length: 16 }
@@ -118,7 +119,7 @@ namespace Mat4 {
         a[4 * j + i] = value;
     }
 
-    export function toArray(a: Mat4, out: Helpers.NumberArray, offset: number) {
+    export function toArray(a: Mat4, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
         out[offset + 2] = a[2];
@@ -137,7 +138,7 @@ namespace Mat4 {
         out[offset + 15] = a[15];
     }
 
-    export function fromArray(a: Mat4, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(a: Mat4, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         a[2] = array[offset + 2]
@@ -370,7 +371,7 @@ namespace Mat4 {
     /**
      * Like `mul` but with offsets into arrays
      */
-    export function mulOffset(out: Helpers.NumberArray, a: Helpers.NumberArray, b: Helpers.NumberArray, oOut: number, oA: number, oB: number) {
+    export function mulOffset(out: NumberArray, a: NumberArray, b: NumberArray, oOut: number, oA: number, oB: number) {
         const a00 = a[0 + oA], a01 = a[1 + oA], a02 = a[2 + oA], a03 = a[3 + oA],
             a10 = a[4 + oA], a11 = a[5 + oA], a12 = a[6 + oA], a13 = a[7 + oA],
             a20 = a[8 + oA], a21 = a[9 + oA], a22 = a[10 + oA], a23 = a[11 + oA],

src/mol-math/linear-algebra/3d/quat.ts

@@ -25,6 +25,7 @@
 import Mat3 from './mat3';
 import Vec3 from './vec3';
 import { EPSILON } from './common';
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Quat extends Array<number> { [d: number]: number, '@type': 'quat', length: 4 }
 
@@ -312,14 +313,14 @@ namespace Quat {
         return out;
     }
 
-    export function toArray(a: Quat, out: Helpers.NumberArray, offset: number) {
+    export function toArray(a: Quat, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
         out[offset + 2] = a[2];
         out[offset + 3] = a[3];
     }
 
-    export function fromArray(a: Quat, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(a: Quat, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         a[2] = array[offset + 2]

src/mol-math/linear-algebra/3d/vec2.ts

@@ -1,3 +1,5 @@
+import { NumberArray } from 'mol-util/type-helpers';
+
 /**
  * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
@@ -44,12 +46,12 @@ namespace Vec2 {
         return isNaN(a[0]) || isNaN(a[1])
     }
 
-    export function toArray(a: Vec2, out: Helpers.NumberArray, offset: number) {
+    export function toArray(a: Vec2, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
     }
 
-    export function fromArray(a: Vec2, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(a: Vec2, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         return a

src/mol-math/linear-algebra/3d/vec3.ts

@@ -20,6 +20,7 @@
 import Mat4 from './mat4';
 import { Quat, Mat3, EPSILON } from '../3d';
 import { spline as _spline, clamp } from '../../interpolate'
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Vec3 extends Array<number> { [d: number]: number, '@type': 'vec3', length: 3 }
 
@@ -57,7 +58,7 @@ namespace Vec3 {
         return v
     }
 
-    export function toArray(v: Vec3, out: Helpers.NumberArray, offset: number) {
+    export function toArray(v: Vec3, out: NumberArray, offset: number) {
         out[offset + 0] = v[0]
         out[offset + 1] = v[1]
         out[offset + 2] = v[2]
@@ -372,7 +373,7 @@ namespace Vec3 {
     /**
      * Like `transformMat4` but with offsets into arrays
      */
-    export function transformMat4Offset(out: Helpers.NumberArray, a: Helpers.NumberArray, m: Helpers.NumberArray, outO: number, aO: number, oM: number) {
+    export function transformMat4Offset(out: NumberArray, a: NumberArray, m: NumberArray, outO: number, aO: number, oM: number) {
         const x = a[0 + aO], y = a[1 + aO], z = a[2 + aO],
             w = 1 / ((m[3 + oM] * x + m[7 + oM] * y + m[11 + oM] * z + m[15 + oM]) || 1.0);
         out[0 + outO] = (m[0 + oM] * x + m[4 + oM] * y + m[8 + oM] * z + m[12 + oM]) * w;

src/mol-math/linear-algebra/3d/vec4.ts

@@ -19,6 +19,7 @@
 
 import Mat4 from './mat4';
 import { EPSILON } from '../3d';
+import { NumberArray } from 'mol-util/type-helpers';
 
 interface Vec4 extends Array<number> { [d: number]: number, '@type': 'vec4', length: 4 }
 
@@ -52,14 +53,14 @@ namespace Vec4 {
         return isNaN(a[0]) || isNaN(a[1]) || isNaN(a[2]) || isNaN(a[3])
     }
 
-    export function toArray(a: Vec4, out: Helpers.NumberArray, offset: number) {
+    export function toArray(a: Vec4, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
         out[offset + 2] = a[2];
         out[offset + 3] = a[3];
     }
 
-    export function fromArray(a: Vec4, array: Helpers.NumberArray, offset: number) {
+    export function fromArray(a: Vec4, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         a[2] = array[offset + 2]
@@ -67,13 +68,13 @@ namespace Vec4 {
         return a
     }
 
-    export function toVec3Array(a: Vec4, out: Helpers.NumberArray, offset: number) {
+    export function toVec3Array(a: Vec4, out: NumberArray, offset: number) {
         out[offset + 0] = a[0];
         out[offset + 1] = a[1];
         out[offset + 2] = a[2];
     }
 
-    export function fromVec3Array(a: Vec4, array: Helpers.NumberArray, offset: number) {
+    export function fromVec3Array(a: Vec4, array: NumberArray, offset: number) {
         a[0] = array[offset + 0]
         a[1] = array[offset + 1]
         a[2] = array[offset + 2]

src/mol-math/linear-algebra/matrix/matrix.ts

@@ -4,15 +4,17 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-interface Matrix { data: Helpers.NumberArray, size: number, cols: number, rows: number }
+import { NumberArray } from 'mol-util/type-helpers';
+
+interface Matrix { data: NumberArray, size: number, cols: number, rows: number }
 
 namespace Matrix {
-    export function create(cols: number, rows: number, ctor: { new (size: number): Helpers.NumberArray } = Float32Array): Matrix {
+    export function create(cols: number, rows: number, ctor: { new (size: number): NumberArray } = Float32Array): Matrix {
         const size = cols * rows
         return { data: new ctor(size), size, cols, rows }
     }
 
-    export function fromArray(data: Helpers.NumberArray, cols: number, rows: number): Matrix {
+    export function fromArray(data: NumberArray, cols: number, rows: number): Matrix {
         return { data, size: cols * rows, cols, rows }
     }
 
@@ -61,7 +63,7 @@ namespace Matrix {
     }
 
     /** Subtract `row` from all rows in `mat` */
-    export function subRows (mat: Matrix, row: Helpers.NumberArray) {
+    export function subRows (mat: Matrix, row: NumberArray) {
         const nrows = mat.rows, ncols = mat.cols
         const md = mat.data
 

src/mol-math/linear-algebra/matrix/svd.ts

@@ -5,10 +5,11 @@
  */
 
 import Matrix from './matrix';
+import { NumberArray } from 'mol-util/type-helpers';
 
 // svd method adapted from http://inspirit.github.io/jsfeat/ MIT Eugene Zatepyakin
 
-export function swap(A: Helpers.NumberArray, i0: number, i1: number, t: number) {
+export function swap(A: NumberArray, i0: number, i1: number, t: number) {
     t = A[i0]
     A[i0] = A[i1]
     A[i1] = t
@@ -31,7 +32,7 @@ export function hypot(a: number, b: number) {
 const EPSILON = 0.0000001192092896
 const FLT_MIN = 1E-37
 
-export function JacobiSVDImpl(At: Helpers.NumberArray, astep: number, _W: Helpers.NumberArray, Vt: Helpers.NumberArray, vstep: number, m: number, n: number, n1: number) {
+export function JacobiSVDImpl(At: NumberArray, astep: number, _W: NumberArray, Vt: NumberArray, vstep: number, m: number, n: number, n1: number) {
     const eps = EPSILON * 2.0
     const minval = FLT_MIN
     let i = 0

src/mol-repr/structure/visual/util/polymer/curve-segment.ts

@@ -5,12 +5,13 @@
  */
 
 import { Vec3 } from 'mol-math/linear-algebra';
+import { NumberArray } from 'mol-util/type-helpers';
 
 export interface CurveSegmentState {
-    curvePoints: Helpers.NumberArray,
-    tangentVectors: Helpers.NumberArray,
-    normalVectors: Helpers.NumberArray,
-    binormalVectors: Helpers.NumberArray,
+    curvePoints: NumberArray,
+    tangentVectors: NumberArray,
+    normalVectors: NumberArray,
+    binormalVectors: NumberArray,
     linearSegments: number
 }
 

src/mol-util/array.ts

@@ -4,10 +4,12 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
+import { NumberArray } from './type-helpers';
+
 // TODO move to mol-math as Vector???
 
 /** Get the maximum value in an array */
-export function arrayMax(array: Helpers.NumberArray) {
+export function arrayMax(array: NumberArray) {
     let max = -Infinity
     for (let i = 0, il = array.length; i < il; ++i) {
         if (array[i] > max) max = array[i]
@@ -16,7 +18,7 @@ export function arrayMax(array: Helpers.NumberArray) {
 }
 
 /** Get the minimum value in an array */
-export function arrayMin(array: Helpers.NumberArray) {
+export function arrayMin(array: NumberArray) {
     let min = Infinity
     for (let i = 0, il = array.length; i < il; ++i) {
         if (array[i] < min) min = array[i]
@@ -25,7 +27,7 @@ export function arrayMin(array: Helpers.NumberArray) {
 }
 
 /** Get the sum of values in an array */
-export function arraySum(array: Helpers.NumberArray, stride = 1, offset = 0) {
+export function arraySum(array: NumberArray, stride = 1, offset = 0) {
     const n = array.length
     let sum = 0
     for (let i = offset; i < n; i += stride) {
@@ -35,12 +37,12 @@ export function arraySum(array: Helpers.NumberArray, stride = 1, offset = 0) {
 }
 
 /** Get the mean of values in an array */
-export function arrayMean(array: Helpers.NumberArray, stride = 1, offset = 0) {
+export function arrayMean(array: NumberArray, stride = 1, offset = 0) {
     return arraySum(array, stride, offset) / (array.length / stride)
 }
 
 /** Get the root mean square of values in an array */
-export function arrayRms(array: Helpers.NumberArray) {
+export function arrayRms(array: NumberArray) {
     const n = array.length
     let sumSq = 0
     for (let i = 0; i < n; ++i) {
@@ -51,7 +53,7 @@ export function arrayRms(array: Helpers.NumberArray) {
 }
 
 /** Fill an array with serial numbers starting from 0 until n - 1 (defaults to array.length) */
-export function fillSerial<T extends Helpers.NumberArray> (array: T, n?: number) {
+export function fillSerial<T extends NumberArray> (array: T, n?: number) {
     for (let i = 0, il = n ? Math.min(n, array.length) : array.length; i < il; ++i) array[ i ] = i
     return array
 }

src/mol-util/color/color.ts

@@ -4,6 +4,8 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
+import { NumberArray } from 'mol-util/type-helpers';
+
 /** RGB color triplet expressed as a single number */
 export type Color = { readonly '@type': 'color' } & number
 
@@ -38,16 +40,16 @@ export namespace Color {
         return (((r * 255) << 16) | ((g * 255) << 8) | (b * 255)) as Color
     }
 
-    export function fromArray(array: Helpers.NumberArray, offset: number): Color {
+    export function fromArray(array: NumberArray, offset: number): Color {
         return fromRgb(array[offset], array[offset + 1], array[offset + 2])
     }
 
-    export function fromNormalizedArray(array: Helpers.NumberArray, offset: number): Color {
+    export function fromNormalizedArray(array: NumberArray, offset: number): Color {
         return fromNormalizedRgb(array[offset], array[offset + 1], array[offset + 2])
     }
 
     /** Copies hex color to rgb array */
-    export function toArray(hexColor: Color, array: Helpers.NumberArray, offset: number) {
+    export function toArray(hexColor: Color, array: NumberArray, offset: number) {
         array[ offset ] = (hexColor >> 16 & 255)
         array[ offset + 1 ] = (hexColor >> 8 & 255)
         array[ offset + 2 ] = (hexColor & 255)
@@ -55,7 +57,7 @@ export namespace Color {
     }
 
     /** Copies normalized (0 to 1) hex color to rgb array */
-    export function toArrayNormalized<T extends Helpers.NumberArray>(hexColor: Color, array: T, offset: number) {
+    export function toArrayNormalized<T extends NumberArray>(hexColor: Color, array: T, offset: number) {
         array[ offset ] = (hexColor >> 16 & 255) / 255
         array[ offset + 1 ] = (hexColor >> 8 & 255) / 255
         array[ offset + 2 ] = (hexColor & 255) / 255

src/mol-util/color/scale.ts

@@ -7,6 +7,7 @@
 import { Color } from './color'
 import { ColorBrewer, ColorMatplotlib, ColorOther } from './tables'
 import { defaults } from 'mol-util';
+import { NumberArray } from 'mol-util/type-helpers';
 
 export type ColorListName = (
     keyof typeof ColorBrewer | keyof typeof ColorMatplotlib | keyof typeof ColorOther
@@ -44,9 +45,9 @@ export interface ColorScale {
     /** Returns hex color for given value */
     color: (value: number) => Color
     /** Copies color to rgb int8 array */
-    colorToArray: (value: number, array: Helpers.NumberArray, offset: number) => void
+    colorToArray: (value: number, array: NumberArray, offset: number) => void
     /** Copies normalized (0 to 1) hex color to rgb array */
-    normalizedColorToArray: (value: number, array: Helpers.NumberArray, offset: number) => void
+    normalizedColorToArray: (value: number, array: NumberArray, offset: number) => void
     /**  */
     setDomain: (min: number, max: number) => void
     /** Legend */
@@ -90,10 +91,10 @@ export namespace ColorScale {
         }
         return {
             color,
-            colorToArray: (value: number, array: Helpers.NumberArray, offset: number) => {
+            colorToArray: (value: number, array: NumberArray, offset: number) => {
                 Color.toArray(color(value), array, offset)
             },
-            normalizedColorToArray: (value: number, array: Helpers.NumberArray, offset: number) => {
+            normalizedColorToArray: (value: number, array: NumberArray, offset: number) => {
                 Color.toArrayNormalized(color(value), array, offset)
             },
             setDomain,

src/mol-util/type-helpers.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2018-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P]
+}
+export type TypedIntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
+export type TypedFloatArray = Float32Array | Float64Array
+
+export type TypedArray = TypedIntArray | TypedFloatArray
+export type NumberArray = TypedArray | number[]
+export type UintArray = Uint8Array | Uint16Array | Uint32Array | number[]
+export type ValueOf<T> = T[keyof T]
+export type ArrayCtor<T> = { new(size: number): { [i: number]: T, length: number } }
+/** assignable ArrayLike version */
+export type AssignableArrayLike<T> =  { [i: number]: T, length: number }