webglimpse
Version:
Webglimpse is a data visualization library for the web.
170 lines • 21 kB
JavaScript
/*
* Copyright (c) 2014, Metron, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Alias for more readable access to static constants
export let GL = WebGLRenderingContext;
export function hasval(value) {
// Double-equals is weird: ( undefined == null ) is true
return (value != null);
}
export function isNumber(value) {
return typeof (value) === 'number';
}
export function isString(value) {
return typeof (value) === 'string';
}
export function isEmpty(array) {
return (array.length === 0);
}
export function notEmpty(array) {
return (array.length > 0);
}
export function alwaysTrue() {
return true;
}
export function alwaysFalse() {
return false;
}
export function constantFn(value) {
return function () {
return value;
};
}
export function log10(x) {
return Math.log(x) * (1.0 / Math.LN10);
}
export function order(x) {
return Math.floor(log10(x) + 1e-12);
}
export function clamp(xMin, xMax, x) {
return Math.max(xMin, Math.min(xMax, x));
}
export function copyArray(values) {
return values.slice(0);
}
export function ensureCapacityFloat32(buffer, minNewCapacity) {
// if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer
if (!minNewCapacity || buffer.length >= minNewCapacity) {
return buffer;
}
else {
const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);
return new Float32Array(newCapacity);
}
}
export function ensureCapacityUint32(buffer, minNewCapacity) {
// if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer
if (!minNewCapacity || buffer.length >= minNewCapacity) {
return buffer;
}
else {
const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);
return new Uint32Array(newCapacity);
}
}
export function ensureCapacityUint16(buffer, minNewCapacity) {
// if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer
if (!minNewCapacity || buffer.length >= minNewCapacity) {
return buffer;
}
else {
const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);
return new Uint16Array(newCapacity);
}
}
export let getObjectId = (function () {
const keyName = 'webglimpse_ObjectId';
let nextValue = 0;
return function (obj) {
let value = obj[keyName];
if (!hasval(value)) {
value = (nextValue++).toString();
obj[keyName] = value;
}
return value;
};
})();
export function concatLines(...lines) {
return lines.join('\n');
}
/**
* Parses a timestamp from the format 'YYYY-MM-DDTHH:mm:ss[.SSS]ZZ' into posix-milliseconds.
*
* Format examples:
* - '2014-01-01T00:00:00Z'
* - '2014-01-01T00:00:00.000+00:00'
*
* Use of a colon in numeric timezones is optional. However, it is strongly encouraged, for
* compatibility with Date in major browsers.
*
* Parsing is strict, and will throw an error if the input string does not match the expected
* format. A notable example is that the seconds field must not have more than three decimal
* places.
*
*/
import moment from 'moment';
export function parseTime_PMILLIS(time_ISO8601) {
// Moment's lenient parsing is way too lenient -- but its strict parsing is a little too
// strict, so we have to try several possible formats.
//
// We could pass in multiple formats to try all at once, but Moment's docs warn that that
// can be slow. Plus, we expect some formats to be more common than others, so we can make
// the common formats fast at the expense of the less common ones.
//
let m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ssZZ', true);
if (m.isValid()) {
return m.valueOf();
}
m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SSSZZ', true);
if (m.isValid()) {
return m.valueOf();
}
m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SSZZ', true);
if (m.isValid()) {
return m.valueOf();
}
m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SZZ', true);
if (m.isValid()) {
return m.valueOf();
}
throw new Error('Failed to parse time-string: \'' + time_ISO8601 + '\'');
}
/**
* Formats a timestamp from posix-millis into the format 'YYYY-MM-DDThh:mm:ss.SSSZZ' (for
* example '2014-01-01T00:00:00.000Z').
*
* The input value is effectively truncated (not rounded!) to milliseconds. So for example,
* formatTime_ISO8601(12345.999) will return '1970-01-01T00:00:12.345Z' -- exactly the same
* as for an input of 12345.
*
*/
export function formatTime_ISO8601(time_PMILLIS) {
return moment(time_PMILLIS).toISOString();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/webglimpse/util/util.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2014, Metron, Inc.\r\n * All rights reserved.\r\n *\r\n * Redistribution and use in source and binary forms, with or without modification,\r\n * are permitted provided that the following conditions are met:\r\n *\r\n * 1. Redistributions of source code must retain the above copyright notice, this\r\n *    list of conditions and the following disclaimer.\r\n *\r\n * 2. Redistributions in binary form must reproduce the above copyright notice,\r\n *    this list of conditions and the following disclaimer in the documentation\r\n *    and/or other materials provided with the distribution.\r\n *\r\n * 3. Neither the name of the copyright holder nor the names of its contributors\r\n *    may be used to endorse or promote products derived from this software without\r\n *    specific prior written permission.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\r\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\r\n * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\r\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\n * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n */\r\n\r\n\r\n// Alias for more readable access to static constants\r\nexport let GL = WebGLRenderingContext;\r\n\r\n\r\nexport function hasval(value: any): boolean {\r\n    // Double-equals is weird: ( undefined == null ) is true\r\n    return (value != null);\r\n}\r\n\r\n\r\nexport function isNumber(value: any): boolean {\r\n    return typeof (value) === 'number';\r\n}\r\n\r\n\r\nexport function isString(value: any): boolean {\r\n    return typeof (value) === 'string';\r\n}\r\n\r\n\r\nexport function isEmpty(array: any[]): boolean {\r\n    return (array.length === 0);\r\n}\r\n\r\n\r\nexport function notEmpty(array: any[]): boolean {\r\n    return (array.length > 0);\r\n}\r\n\r\n\r\nexport function alwaysTrue(): boolean {\r\n    return true;\r\n}\r\n\r\n\r\nexport function alwaysFalse(): boolean {\r\n    return false;\r\n}\r\n\r\n\r\nexport function constantFn<V>(value: V): () => V {\r\n    return function (): V {\r\n        return value;\r\n    };\r\n}\r\n\r\n\r\nexport function log10(x: number): number {\r\n    return Math.log(x) * (1.0 / Math.LN10);\r\n}\r\n\r\n\r\nexport function order(x: number): number {\r\n    return Math.floor(log10(x) + 1e-12);\r\n}\r\n\r\n\r\nexport function clamp(xMin: number, xMax: number, x: number): number {\r\n    return Math.max(xMin, Math.min(xMax, x));\r\n}\r\n\r\n\r\nexport function copyArray<T>(values: T[]): T[] {\r\n    return values.slice(0);\r\n}\r\n\r\n\r\nexport function ensureCapacityFloat32(buffer: Float32Array, minNewCapacity: number): Float32Array {\r\n    // if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer\r\n    if (!minNewCapacity || buffer.length >= minNewCapacity) {\r\n        return buffer;\r\n    }\r\n    else {\r\n        const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);\r\n        return new Float32Array(newCapacity);\r\n    }\r\n}\r\n\r\n\r\nexport function ensureCapacityUint32(buffer: Uint32Array, minNewCapacity: number): Uint32Array {\r\n    // if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer\r\n    if (!minNewCapacity || buffer.length >= minNewCapacity) {\r\n        return buffer;\r\n    }\r\n    else {\r\n        const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);\r\n        return new Uint32Array(newCapacity);\r\n    }\r\n}\r\n\r\n\r\nexport function ensureCapacityUint16(buffer: Uint16Array, minNewCapacity: number): Uint16Array {\r\n    // if minNewCapacity is NaN, null, or undefined, don't try to resize the buffer\r\n    if (!minNewCapacity || buffer.length >= minNewCapacity) {\r\n        return buffer;\r\n    }\r\n    else {\r\n        const newCapacity = Math.max(minNewCapacity, 2 * buffer.length);\r\n        return new Uint16Array(newCapacity);\r\n    }\r\n}\r\n\r\n\r\nexport interface StringMap<V> {\r\n    [key: string]: V;\r\n}\r\n\r\nexport type IdFunction<V> = (value: V) => string;\r\n\r\n\r\nexport let getObjectId = (function () {\r\n    const keyName = 'webglimpse_ObjectId';\r\n    let nextValue = 0;\r\n    return function (obj: any): string {\r\n        let value = obj[keyName];\r\n        if (!hasval(value)) {\r\n            value = (nextValue++).toString();\r\n            obj[keyName] = value;\r\n        }\r\n        return value;\r\n    };\r\n})();\r\n\r\n\r\nexport function concatLines(...lines: string[]) {\r\n    return lines.join('\\n');\r\n}\r\n\r\n\r\n/**\r\n * Parses a timestamp from the format 'YYYY-MM-DDTHH:mm:ss[.SSS]ZZ' into posix-milliseconds.\r\n *\r\n * Format examples:\r\n *   - '2014-01-01T00:00:00Z'\r\n *   - '2014-01-01T00:00:00.000+00:00'\r\n *\r\n * Use of a colon in numeric timezones is optional. However, it is strongly encouraged, for\r\n * compatibility with Date in major browsers.\r\n *\r\n * Parsing is strict, and will throw an error if the input string does not match the expected\r\n * format. A notable example is that the seconds field must not have more than three decimal\r\n * places.\r\n *\r\n */\r\nimport moment from 'moment';\r\n\r\nexport function parseTime_PMILLIS(time_ISO8601: string): number {\r\n\r\n    // Moment's lenient parsing is way too lenient -- but its strict parsing is a little too\r\n    // strict, so we have to try several possible formats.\r\n    //\r\n    // We could pass in multiple formats to try all at once, but Moment's docs warn that that\r\n    // can be slow. Plus, we expect some formats to be more common than others, so we can make\r\n    // the common formats fast at the expense of the less common ones.\r\n    //\r\n\r\n    let m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ssZZ', true);\r\n    if (m.isValid()) {\r\n        return m.valueOf();\r\n    }\r\n\r\n    m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SSSZZ', true);\r\n    if (m.isValid()) {\r\n        return m.valueOf();\r\n    }\r\n\r\n    m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SSZZ', true);\r\n    if (m.isValid()) {\r\n        return m.valueOf();\r\n    }\r\n\r\n    m = moment(time_ISO8601, 'YYYY-MM-DDTHH:mm:ss.SZZ', true);\r\n    if (m.isValid()) {\r\n        return m.valueOf();\r\n    }\r\n\r\n    throw new Error('Failed to parse time-string: \\'' + time_ISO8601 + '\\'');\r\n}\r\n\r\n\r\n/**\r\n * Formats a timestamp from posix-millis into the format 'YYYY-MM-DDThh:mm:ss.SSSZZ' (for\r\n * example '2014-01-01T00:00:00.000Z').\r\n *\r\n * The input value is effectively truncated (not rounded!) to milliseconds. So for example,\r\n * formatTime_ISO8601(12345.999) will return '1970-01-01T00:00:12.345Z' -- exactly the same\r\n * as for an input of 12345.\r\n *\r\n */\r\nexport function formatTime_ISO8601(time_PMILLIS: number): string {\r\n    return moment(time_PMILLIS).toISOString();\r\n}\r\n\r\n\r\n\r\n"]}