@ixfx/debug 0.36.0

package/dist/__tests__/test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test.d.ts.map

package/dist/__tests__/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../__tests__/test.ts"],"names":[],"mappings":""}

package/dist/__tests__/test.js

@@ -0,0 +1 @@
+export {};

package/dist/src/fps-counter.d.ts

@@ -0,0 +1,2 @@
+export declare const fpsCounter: (autoDisplay?: boolean, computeAfterFrames?: number) => () => number;
+//# sourceMappingURL=fps-counter.d.ts.map

package/dist/src/fps-counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fps-counter.d.ts","sourceRoot":"","sources":["../../src/fps-counter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,GAAI,qBAAkB,EAAE,2BAAwB,iBAetE,CAAA"}

package/dist/src/fps-counter.js

@@ -0,0 +1,16 @@
+export const fpsCounter = (autoDisplay = true, computeAfterFrames = 500) => {
+    let count = 0;
+    let lastFps = 0;
+    let countStart = performance.now();
+    return () => {
+        if (count++ >= computeAfterFrames) {
+            const elapsed = performance.now() - countStart;
+            countStart = performance.now();
+            count = 0;
+            lastFps = Math.floor((computeAfterFrames / elapsed) * 1000);
+            if (autoDisplay)
+                console.log(`fps: ${lastFps}`);
+        }
+        return lastFps;
+    };
+};

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './logger.js';
+export * from './fps-counter.js';
+export declare const getErrorMessage: (ex: unknown) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AAEjC,eAAO,MAAM,eAAe,GAAI,IAAI,OAAO,KAAG,MAM7C,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './logger.js';
+export * from './fps-counter.js';
+export const getErrorMessage = (ex) => {
+    if (typeof ex === `string`)
+        return ex;
+    if (ex instanceof Error) {
+        return ex.message;
+    }
+    return ex;
+};

package/dist/src/logger.d.ts

@@ -0,0 +1,77 @@
+import type { MessageLogger } from "./types.js";
+/**
+ * Returns a console logging function which prefixes messages. This is
+ * useful for tracing messages from different components. Each prefix
+ * is assigned a colour, further helping to distinguish messages.
+ *
+ * Use {@link logSet} to get a bundled set.
+ *
+ * ```
+ * // Initialise once
+ * const log = logger(`a`);
+ * const error = logger(`a`, `error`);
+ * const warn = logger(`a`, `warn);
+ *
+ * // And then use
+ * log(`Hello`);    // console.log(`a Hello`);
+ * error(`Uh-oh`);  // console.error(`a Uh-oh`);
+ * warn(`Eek!`);    // console.warn(`a Eeek!`);
+ * ```
+ *
+ * Provide the `colourKey` parameter to make log messages
+ * be coloured the same, even though the prefix is different.
+ * ```js
+ * // Both loggers will use the same colour because they
+ * // share the colour key `system`
+ * const log = logger(`a`,`log`,`system`);
+ * const log2 = logger(`b`, `log`, `system`);
+ * ```
+ * @param prefix
+ * @param kind
+ * @param colourKey Optional key to colour log lines by instead of prefix
+ * @returns
+ */
+export declare const logger: (prefix: string, kind?: `log` | `warn` | `error`, colourKey?: string) => MessageLogger;
+/**
+* Returns a bundled collection of {@link logger}s
+*
+* ```js
+* const con = logSet(`a`);
+* con.log(`Hello`);  // console.log(`a Hello`);
+* con.warn(`Uh-oh`); // console.warn(`a Uh-oh`);
+* con.error(`Eek!`); // console.error(`a Eek!`);
+* ```
+*
+* By default each prefix is assigned a colour. To use
+* another logic, provide the `colourKey` parameter.
+*
+* ```js
+* // Both set of loggers will use same colour
+* const con = logSet(`a`, true, `system`);
+* const con2 = logSet(`b`, true, `system`);
+* ```
+* @param prefix Prefix for log messages
+* @param verbose True by default. If false, log() messages are a no-op
+* @param colourKey If specified, log messages will be coloured by this key instead of prefix (default)
+* @returns
+*/
+export declare const logSet: (prefix: string, verbose?: boolean, colourKey?: string) => {
+    log: MessageLogger;
+    warn: MessageLogger;
+    error: MessageLogger;
+};
+/**
+ * Either a flag for default console logging, or a simple log function
+ */
+export type LogOption = boolean | MessageLogger;
+/**
+ * Resolve a LogOption to a function
+ * @param l
+ * @returns
+ */
+export declare const resolveLogOption: (l?: LogOption, defaults?: {
+    readonly category?: string;
+    readonly kind?: string;
+}) => MessageLogger;
+export declare const logColours: (key: string, args?: unknown) => string;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,YAAY,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAKH,eAAO,MAAM,MAAM,GAEf,QAAQ,MAAM,EACd,OAAM,KAAK,GAAG,MAAM,GAAG,OAAe,EACtC,YAAY,MAAM,KACjB,aAuBA,CAAC;AAEN;;;;;;;;;;;;;;;;;;;;;;EAsBE;AACF,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,EAAE,iBAAc,EAAE,YAAY,MAAM;;;;CAgBxE,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,aAAa,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAC3B,IAAI,SAAS,EACb,WAAU;IAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,KACpE,aAqCF,CAAC;AAIF,eAAO,MAAM,UAAU,yCAGrB,CAAC"}

package/dist/src/logger.js

@@ -0,0 +1,142 @@
+import { getOrGenerateSync } from "./util.js";
+/**
+ * Returns a console logging function which prefixes messages. This is
+ * useful for tracing messages from different components. Each prefix
+ * is assigned a colour, further helping to distinguish messages.
+ *
+ * Use {@link logSet} to get a bundled set.
+ *
+ * ```
+ * // Initialise once
+ * const log = logger(`a`);
+ * const error = logger(`a`, `error`);
+ * const warn = logger(`a`, `warn);
+ *
+ * // And then use
+ * log(`Hello`);    // console.log(`a Hello`);
+ * error(`Uh-oh`);  // console.error(`a Uh-oh`);
+ * warn(`Eek!`);    // console.warn(`a Eeek!`);
+ * ```
+ *
+ * Provide the `colourKey` parameter to make log messages
+ * be coloured the same, even though the prefix is different.
+ * ```js
+ * // Both loggers will use the same colour because they
+ * // share the colour key `system`
+ * const log = logger(`a`,`log`,`system`);
+ * const log2 = logger(`b`, `log`, `system`);
+ * ```
+ * @param prefix
+ * @param kind
+ * @param colourKey Optional key to colour log lines by instead of prefix
+ * @returns
+ */
+export const logger = (prefix, kind = `log`, colourKey) => (m) => {
+    if (m === undefined) {
+        m = `(undefined)`;
+    }
+    else if (typeof m === `object`) {
+        m = JSON.stringify(m);
+    }
+    const colour = colourKey ?? prefix;
+    switch (kind) {
+        case `log`: {
+            console.log(`%c${prefix} ${m}`, `color: ${logColours(colour)}`);
+            break;
+        }
+        case `warn`: {
+            console.warn(prefix, m);
+            break;
+        }
+        case `error`: {
+            console.error(prefix, m);
+            break;
+        }
+    }
+};
+/**
+* Returns a bundled collection of {@link logger}s
+*
+* ```js
+* const con = logSet(`a`);
+* con.log(`Hello`);  // console.log(`a Hello`);
+* con.warn(`Uh-oh`); // console.warn(`a Uh-oh`);
+* con.error(`Eek!`); // console.error(`a Eek!`);
+* ```
+*
+* By default each prefix is assigned a colour. To use
+* another logic, provide the `colourKey` parameter.
+*
+* ```js
+* // Both set of loggers will use same colour
+* const con = logSet(`a`, true, `system`);
+* const con2 = logSet(`b`, true, `system`);
+* ```
+* @param prefix Prefix for log messages
+* @param verbose True by default. If false, log() messages are a no-op
+* @param colourKey If specified, log messages will be coloured by this key instead of prefix (default)
+* @returns
+*/
+export const logSet = (prefix, verbose = true, colourKey) => {
+    if (verbose) {
+        return {
+            log: logger(prefix, `log`, colourKey),
+            warn: logger(prefix, `warn`, colourKey),
+            error: logger(prefix, `error`, colourKey),
+        };
+    }
+    return {
+        log: (_) => {
+            /** no-op */
+        },
+        warn: logger(prefix, `warn`, colourKey),
+        error: logger(prefix, `error`, colourKey),
+    };
+};
+/**
+ * Resolve a LogOption to a function
+ * @param l
+ * @returns
+ */
+export const resolveLogOption = (l, defaults = {}) => {
+    if (l === undefined || (typeof l === `boolean` && !l)) {
+        return (_) => {
+            /** no-op */
+        };
+    }
+    const defaultCat = defaults.category ?? ``;
+    const defaultKind = defaults.kind ?? undefined;
+    if (typeof l === `boolean`) {
+        return (messageOrString) => {
+            const m = typeof messageOrString === `string` ? { msg: messageOrString } : messageOrString;
+            const kind = m.kind ?? defaultKind;
+            const category = m.category ?? defaultCat;
+            let message = m.msg;
+            if (category)
+                message = `[${category}] ${message}`;
+            switch (kind) {
+                case `error`: {
+                    console.error(message);
+                    break;
+                }
+                case `warn`: {
+                    console.warn(message);
+                    break;
+                }
+                case `info`: {
+                    console.info(message);
+                    break;
+                }
+                default: {
+                    console.log(message);
+                }
+            }
+        };
+    }
+    return l;
+};
+let logColourCount = 0;
+export const logColours = getOrGenerateSync(new Map(), () => {
+    const hue = ++logColourCount * 137.508; // use golden angle approximation
+    return `hsl(${hue},50%,75%)`;
+});

package/dist/src/types.d.ts

@@ -0,0 +1,13 @@
+export type LogSet = {
+    readonly log: MessageLogger;
+    readonly warn: MessageLogger;
+    readonly error: MessageLogger;
+};
+export type MessageLogger = (message: LogMessage | string) => void;
+export type LogKind = `info` | `debug` | `error` | `warn`;
+export type LogMessage = {
+    readonly kind?: LogKind;
+    readonly msg: any;
+    readonly category?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B,CAAA;AACD,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,KAAK,IAAI,CAAC;AACnE,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAC1D,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAA"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/util.d.ts

@@ -0,0 +1,2 @@
+export declare const getOrGenerateSync: <K, V, Z>(map: Map<K, V>, fn: (key: K, args?: Z) => V) => (key: K, args?: Z) => V;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,GAC3B,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,MAClD,KAAK,CAAC,EAAE,OAAO,CAAC,KAAG,CAMnB,CAAC"}

package/dist/src/util.js

@@ -0,0 +1,8 @@
+export const getOrGenerateSync = (map, fn) => (key, args) => {
+    let value = map.get(key);
+    if (value !== undefined)
+        return value;
+    value = fn(key, args);
+    map.set(key, value);
+    return value;
+};

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/fps-counter.ts","../src/index.ts","../src/logger.ts","../src/types.ts","../src/util.ts","../__tests__/test.ts"],"version":"5.8.3"}

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@ixfx/debug",
+	"version": "0.36.0",
+	"license": "MIT",
+	"type": "module",
+	"sideEffects": false,
+	"files": [
+		"dist/"
+	],
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		}
+	},
+	"dependencies": {},
+	"publishConfig": {
+		"main": "dist/src/index.js",
+		"exports": {
+			".": {
+				"types": "./dist/src/index.d.ts",
+				"import": "./dist/src/index.js"
+			}
+		}
+	}
+}