@hpcc-js/util 3.5.4 → 3.5.6

package/src/logging.ts

@@ -1,212 +1,212 @@
-/* eslint-disable no-console */
-import { isNode } from "./platform.ts";
-import { Stack } from "./stack.ts";
-
-export enum Level {
-    debug,
-    info,
-    notice,
-    warning,
-    error,
-    critical,
-    alert,
-    emergency
-}
-
-const colours: { [key: string]: string } = {
-    debug: "cyan",
-    info: "green",
-    notice: "grey",
-    warning: "blue",
-    error: "red",
-    critical: "magenta",
-    alert: "magenta",
-    emergency: "magenta"
-};
-
-export interface Writer {
-    write?(dateTime: string, level: Level, id: string, msg: string): void;
-    rawWrite?(dateTime: string, level: Level, id: string, msg: string | object): void;
-}
-
-class ConsoleWriter implements Writer {
-    write(dateTime: string, level: Level, id: string, msg: string) {
-        if (isNode) {
-            console.log(`[${dateTime}] ${Level[level].toUpperCase()} ${id}:  ${msg}`);
-        } else {
-            console.log(`[${dateTime}] %c${Level[level].toUpperCase()}%c ${id}:  ${msg}`, `color:${colours[Level[level]]}`, "");
-        }
-    }
-}
-
-export class Logging {
-    private static _instance: Logging;
-    private _levelStack = new Stack<Level>();
-    private _level = Level.info;
-    private _filter: string = "";
-    private _writer: Writer = new ConsoleWriter();
-
-    public static Instance() {
-        return this._instance || (this._instance = new this());
-    }
-
-    private constructor() {
-    }
-
-    private stringify(obj: object): string {
-        const cache: any[] = [];
-        return JSON.stringify(obj, function (_key, value) {
-            if (typeof value === "object" && value !== null) {
-                if (cache.indexOf(value) !== -1) {
-                    return;
-                }
-                cache.push(value);
-            }
-            return value;
-        }, 2);
-    }
-
-    writer(): Writer;
-    writer(_: Writer): Logging;
-    writer(_?: Writer): Writer | Logging {
-        if (_ === void 0) return this._writer;
-        this._writer = _;
-        return this;
-    }
-
-    log(level: Level, id: string, msg: string | object) {
-        if (level < this._level) return;
-        if (this._filter && this._filter !== id) return;
-
-        const dateTime = new Date().toISOString();
-
-        if (this._writer.rawWrite) {
-            this._writer.rawWrite(dateTime, level, id, msg);
-        } else {
-            if (typeof msg !== "string") {
-                msg = this.stringify(msg);
-            }
-
-            if (this._writer.write) {
-                this._writer.write(dateTime, level, id, msg);
-            }
-        }
-    }
-
-    debug(id: string, msg: string | object) {
-        this.log(Level.debug, id, msg);
-    }
-
-    info(id: string, msg: string | object) {
-        this.log(Level.info, id, msg);
-    }
-
-    notice(id: string, msg: string | object) {
-        this.log(Level.notice, id, msg);
-    }
-
-    warning(id: string, msg: string | object) {
-        this.log(Level.warning, id, msg);
-    }
-
-    error(id: string, msg: string | object) {
-        this.log(Level.error, id, msg);
-    }
-
-    critical(id: string, msg: string | object) {
-        this.log(Level.critical, id, msg);
-    }
-
-    alert(id: string, msg: string | object) {
-        this.log(Level.alert, id, msg);
-    }
-
-    emergency(id: string, msg: string | object) {
-        this.log(Level.emergency, id, msg);
-    }
-
-    level(): Level;
-    level(_: Level): this;
-    level(_?: Level): Level | this {
-        if (_ === void 0) return this._level;
-        this._level = _;
-        return this;
-    }
-
-    pushLevel(_: Level): this {
-        this._levelStack.push(this._level);
-        this._level = _;
-        return this;
-    }
-
-    popLevel(): this {
-        this._level = this._levelStack.pop()!;
-        return this;
-    }
-
-    filter(): string;
-    filter(_: string): this;
-    filter(_?: string): string | this {
-        if (_ === void 0) return this._filter;
-        this._filter = _;
-        return this;
-    }
-}
-export const logger = Logging.Instance();
-
-export class ScopedLogging {
-    protected _scopeID: string;
-
-    constructor(scopeID: string) {
-        this._scopeID = scopeID;
-    }
-
-    debug(msg: string | object) {
-        logger.debug(this._scopeID, msg);
-    }
-
-    info(msg: string | object) {
-        logger.info(this._scopeID, msg);
-    }
-
-    notice(msg: string | object) {
-        logger.notice(this._scopeID, msg);
-    }
-
-    warning(msg: string | object) {
-        logger.warning(this._scopeID, msg);
-    }
-
-    error(msg: string | object) {
-        logger.error(this._scopeID, msg);
-    }
-
-    critical(msg: string | object) {
-        logger.critical(this._scopeID, msg);
-    }
-
-    alert(msg: string | object) {
-        logger.alert(this._scopeID, msg);
-    }
-
-    emergency(msg: string | object) {
-        logger.emergency(this._scopeID, msg);
-    }
-
-    pushLevel(_: Level): this {
-        logger.pushLevel(_);
-        return this;
-    }
-
-    popLevel(): this {
-        logger.popLevel();
-        return this;
-    }
-}
-
-export function scopedLogger(scopeID: string, filter: boolean = false) {
-    if (filter) {
-        logger.filter(scopeID);
-    }
-    return new ScopedLogging(scopeID);
-}
+/* eslint-disable no-console */
+import { isNode } from "./platform.ts";
+import { Stack } from "./stack.ts";
+
+export enum Level {
+    debug,
+    info,
+    notice,
+    warning,
+    error,
+    critical,
+    alert,
+    emergency
+}
+
+const colours: { [key: string]: string } = {
+    debug: "cyan",
+    info: "green",
+    notice: "grey",
+    warning: "blue",
+    error: "red",
+    critical: "magenta",
+    alert: "magenta",
+    emergency: "magenta"
+};
+
+export interface Writer {
+    write?(dateTime: string, level: Level, id: string, msg: string): void;
+    rawWrite?(dateTime: string, level: Level, id: string, msg: string | object): void;
+}
+
+class ConsoleWriter implements Writer {
+    write(dateTime: string, level: Level, id: string, msg: string) {
+        if (isNode) {
+            console.log(`[${dateTime}] ${Level[level].toUpperCase()} ${id}:  ${msg}`);
+        } else {
+            console.log(`[${dateTime}] %c${Level[level].toUpperCase()}%c ${id}:  ${msg}`, `color:${colours[Level[level]]}`, "");
+        }
+    }
+}
+
+export class Logging {
+    private static _instance: Logging;
+    private _levelStack = new Stack<Level>();
+    private _level = Level.info;
+    private _filter: string = "";
+    private _writer: Writer = new ConsoleWriter();
+
+    public static Instance() {
+        return this._instance || (this._instance = new this());
+    }
+
+    private constructor() {
+    }
+
+    private stringify(obj: object): string {
+        const cache: any[] = [];
+        return JSON.stringify(obj, function (_key, value) {
+            if (typeof value === "object" && value !== null) {
+                if (cache.indexOf(value) !== -1) {
+                    return;
+                }
+                cache.push(value);
+            }
+            return value;
+        }, 2);
+    }
+
+    writer(): Writer;
+    writer(_: Writer): Logging;
+    writer(_?: Writer): Writer | Logging {
+        if (_ === void 0) return this._writer;
+        this._writer = _;
+        return this;
+    }
+
+    log(level: Level, id: string, msg: string | object) {
+        if (level < this._level) return;
+        if (this._filter && this._filter !== id) return;
+
+        const dateTime = new Date().toISOString();
+
+        if (this._writer.rawWrite) {
+            this._writer.rawWrite(dateTime, level, id, msg);
+        } else {
+            if (typeof msg !== "string") {
+                msg = this.stringify(msg);
+            }
+
+            if (this._writer.write) {
+                this._writer.write(dateTime, level, id, msg);
+            }
+        }
+    }
+
+    debug(id: string, msg: string | object) {
+        this.log(Level.debug, id, msg);
+    }
+
+    info(id: string, msg: string | object) {
+        this.log(Level.info, id, msg);
+    }
+
+    notice(id: string, msg: string | object) {
+        this.log(Level.notice, id, msg);
+    }
+
+    warning(id: string, msg: string | object) {
+        this.log(Level.warning, id, msg);
+    }
+
+    error(id: string, msg: string | object) {
+        this.log(Level.error, id, msg);
+    }
+
+    critical(id: string, msg: string | object) {
+        this.log(Level.critical, id, msg);
+    }
+
+    alert(id: string, msg: string | object) {
+        this.log(Level.alert, id, msg);
+    }
+
+    emergency(id: string, msg: string | object) {
+        this.log(Level.emergency, id, msg);
+    }
+
+    level(): Level;
+    level(_: Level): this;
+    level(_?: Level): Level | this {
+        if (_ === void 0) return this._level;
+        this._level = _;
+        return this;
+    }
+
+    pushLevel(_: Level): this {
+        this._levelStack.push(this._level);
+        this._level = _;
+        return this;
+    }
+
+    popLevel(): this {
+        this._level = this._levelStack.pop()!;
+        return this;
+    }
+
+    filter(): string;
+    filter(_: string): this;
+    filter(_?: string): string | this {
+        if (_ === void 0) return this._filter;
+        this._filter = _;
+        return this;
+    }
+}
+export const logger = Logging.Instance();
+
+export class ScopedLogging {
+    protected _scopeID: string;
+
+    constructor(scopeID: string) {
+        this._scopeID = scopeID;
+    }
+
+    debug(msg: string | object) {
+        logger.debug(this._scopeID, msg);
+    }
+
+    info(msg: string | object) {
+        logger.info(this._scopeID, msg);
+    }
+
+    notice(msg: string | object) {
+        logger.notice(this._scopeID, msg);
+    }
+
+    warning(msg: string | object) {
+        logger.warning(this._scopeID, msg);
+    }
+
+    error(msg: string | object) {
+        logger.error(this._scopeID, msg);
+    }
+
+    critical(msg: string | object) {
+        logger.critical(this._scopeID, msg);
+    }
+
+    alert(msg: string | object) {
+        logger.alert(this._scopeID, msg);
+    }
+
+    emergency(msg: string | object) {
+        logger.emergency(this._scopeID, msg);
+    }
+
+    pushLevel(_: Level): this {
+        logger.pushLevel(_);
+        return this;
+    }
+
+    popLevel(): this {
+        logger.popLevel();
+        return this;
+    }
+}
+
+export function scopedLogger(scopeID: string, filter: boolean = false) {
+    if (filter) {
+        logger.filter(scopeID);
+    }
+    return new ScopedLogging(scopeID);
+}

package/src/math.ts

@@ -1,92 +1,92 @@
-/**
- * degreesToRadians - converts degrees to radians
- * Usage: degreesToRadians(1080);
- *
- * @param degrees
- * @returns Number radians
- */
-export function degreesToRadians(degrees: number): number {
-    return degrees * (Math.PI / 180);
-}
-
-/**
- * radiansToDegrees - converts radians to degrees
- * Usage: radiansToDegrees(7);
- *
- * @param radians
- * @returns Number degreees
- */
-export function radiansToDegrees(radians: number): number {
-    return radians * (180 / Math.PI);
-}
-
-/**
- * polarToCartesian - converts (r, theta) to {x, y}
- * Usage: polarToCartesian(5, Math.PI);
- *
- * @param r radius
- * @param theta angle in radians
- * @returns { x: number, y: number }
- */
-export function polarToCartesian(r: number, theta: number): { x:number, y:number } {
-    return {
-        x: r * Math.cos(theta),
-        y: r * Math.sin(theta)
-    };
-}
-
-/**
- * cartesianToPolar - converts (x, y) to {r, theta}
- * Usage: cartesianToPolar(100, 200);
- *
- * @param x
- * @param y
- * @returns { r: number, theta: number }
- */
-export function cartesianToPolar(x: number, y: number): { r: number, theta: number } {
-    return {
-        r: Math.sqrt(x * x + y * y),
-        theta: Math.atan2(y, x)
-    };
-}
-
-/**
- * normalizeRadians - normalizes a radian value to within the provided range
- * Usage: normalizeRadians(7);
- *
- * @param radians value to be normalized
- * @param min lower limit
- * @param max upper limit
- * @returns Number normalized to within the provided range
- */
-export function normalizeRadians(radians: number, min: number = -Math.PI, max: number = Math.PI): number {
-    return normalize(radians, min, max);
-}
-
-/**
- * normalizeDegrees - normalizes a degree value to within the provided range
- * Usage: normalizeDegrees(1080);
- *
- * @param degrees value to be normalized
- * @param min lower limit
- * @param max upper limit
- * @returns Number normalized to within the provided range
- */
-export function normalizeDegrees(degrees: number, min: number = -180, max: number = 180): number {
-    return normalize(degrees, min, max);
-}
-
-/**
- * normalize - normalizes a value to within the provided range
- * Usage: normalize(1000, 0, 365);
- *
- * @param value value to be normalized
- * @param min lower limit
- * @param max upper limit
- * @returns Number normalized to within the provided range
- */
-export function normalize(value: number, min: number, max: number): number {
-    const spread = max - min;
-    const offsetValue = value - min;
-    return (offsetValue - (Math.floor(offsetValue / spread) * spread)) + min;
-}
+/**
+ * degreesToRadians - converts degrees to radians
+ * Usage: degreesToRadians(1080);
+ *
+ * @param degrees
+ * @returns Number radians
+ */
+export function degreesToRadians(degrees: number): number {
+    return degrees * (Math.PI / 180);
+}
+
+/**
+ * radiansToDegrees - converts radians to degrees
+ * Usage: radiansToDegrees(7);
+ *
+ * @param radians
+ * @returns Number degreees
+ */
+export function radiansToDegrees(radians: number): number {
+    return radians * (180 / Math.PI);
+}
+
+/**
+ * polarToCartesian - converts (r, theta) to {x, y}
+ * Usage: polarToCartesian(5, Math.PI);
+ *
+ * @param r radius
+ * @param theta angle in radians
+ * @returns { x: number, y: number }
+ */
+export function polarToCartesian(r: number, theta: number): { x:number, y:number } {
+    return {
+        x: r * Math.cos(theta),
+        y: r * Math.sin(theta)
+    };
+}
+
+/**
+ * cartesianToPolar - converts (x, y) to {r, theta}
+ * Usage: cartesianToPolar(100, 200);
+ *
+ * @param x
+ * @param y
+ * @returns { r: number, theta: number }
+ */
+export function cartesianToPolar(x: number, y: number): { r: number, theta: number } {
+    return {
+        r: Math.sqrt(x * x + y * y),
+        theta: Math.atan2(y, x)
+    };
+}
+
+/**
+ * normalizeRadians - normalizes a radian value to within the provided range
+ * Usage: normalizeRadians(7);
+ *
+ * @param radians value to be normalized
+ * @param min lower limit
+ * @param max upper limit
+ * @returns Number normalized to within the provided range
+ */
+export function normalizeRadians(radians: number, min: number = -Math.PI, max: number = Math.PI): number {
+    return normalize(radians, min, max);
+}
+
+/**
+ * normalizeDegrees - normalizes a degree value to within the provided range
+ * Usage: normalizeDegrees(1080);
+ *
+ * @param degrees value to be normalized
+ * @param min lower limit
+ * @param max upper limit
+ * @returns Number normalized to within the provided range
+ */
+export function normalizeDegrees(degrees: number, min: number = -180, max: number = 180): number {
+    return normalize(degrees, min, max);
+}
+
+/**
+ * normalize - normalizes a value to within the provided range
+ * Usage: normalize(1000, 0, 365);
+ *
+ * @param value value to be normalized
+ * @param min lower limit
+ * @param max upper limit
+ * @returns Number normalized to within the provided range
+ */
+export function normalize(value: number, min: number, max: number): number {
+    const spread = max - min;
+    const offsetValue = value - min;
+    return (offsetValue - (Math.floor(offsetValue / spread) * spread)) + min;
+}