@hkdigital/lib-core 0.3.9 → 0.3.11

package/dist/util/function/index.js

@@ -1,218 +1,218 @@
-/**
- * function.js
- *
- * @description
- * This file contains code for working with functions
- *
- * @example
- *
- *   import { once } from "./function.js";
- *
- *   const sayHelloOnce = once( () => { console.log("Hello"); } );
- *
- *   sayHelloOnce();
- *   sayHelloOnce();
- *
- * @example
- *
- *   import { defer } from './process.js';
- *
- *   defer( () => {
- *     console.log("The execution of the function has been defered");
- *   } );
- */
-
-/* ------------------------------------------------------------------ Imports */
-
-import * as expect from '../expect/index.js';
-
-/* ---------------------------------------------------------------- Internals */
-
-const NEXT_TICK_MESSAGE = 'hk-next-tick';
-
-/**
- * Detect and return the most suitable setImmediate implementation available
- * on the current platform
- */
-function set_immediate_implementation() {
-	if (typeof global !== 'undefined') {
-		if (undefined !== global.setImmediate) {
-			return global.setImmediate;
-		}
-	} else if (typeof window !== 'undefined') {
-		if (window.postMessage && window.addEventListener) {
-			const queue = [];
-
-			window.addEventListener(
-				'message',
-				(event) => {
-					const source = event.source;
-
-					if ((source === window || source === null) && event.data === NEXT_TICK_MESSAGE) {
-						event.stopPropagation();
-						if (queue.length > 0) {
-							const fn = queue.shift();
-							fn();
-						}
-					}
-				},
-				true
-			);
-
-			return function nextTickUsingPostMessage(fn) {
-				expect.function(fn);
-
-				queue.push(fn);
-				window.postMessage(NEXT_TICK_MESSAGE, '*');
-			};
-		}
-	}
-
-	throw new Error('No suitable [setImmediate] implementation available');
-}
-
-/* ------------------------------------------------------------------ Exports */
-
-/**
- * 'No operation' function
- * - A function that does nothing
- */
-export const noop = () => {};
-
-// -----------------------------------------------------------------------------
-
-/**
- * Wraps a function so that the callback function will be called only once
- *
- * @param {function} callback
- *
- * @returns {function} callback wrapped in `once` function
- */
-export function once(callback) {
-	expect.function(callback);
-
-	let ignore = false;
-
-	return function () {
-		if (!ignore) {
-			ignore = true;
-			callback(...arguments);
-		}
-	};
-}
-
-// -----------------------------------------------------------------------------
-
-/**
- * Returns a debounced function
- * - The original function is not called more than once during the
- *   specified interval
- *
- * @param {function} fn
- * @param {number} [intervalMs=200]
- *
- * @returns {function} debounced function
- */
-export function debounce(fn, intervalMs = 200) {
-	let idleTimer;
-	let lastArguments;
-
-	// console.log("debounce");
-
-	return function debounced() {
-		// console.log("debounced");
-
-		if (idleTimer) {
-			// console.log("idleTimer running");
-
-			// The function has been called recently
-			lastArguments = arguments;
-			return;
-		}
-
-		idleTimer = setTimeout(() => {
-			// console.log("idleTimer finished", lastArguments);
-
-			idleTimer = null;
-
-			if (lastArguments) {
-				//
-				// At least one call has been "debounced"
-				// -> make call with last arguments, so function always receives
-				//    the arguments of the last call to the function
-				//
-				fn(...lastArguments);
-				lastArguments = undefined;
-			}
-		}, intervalMs);
-
-		fn(...arguments);
-	};
-}
-
-// -----------------------------------------------------------------------------
-
-/**
- * Defer the execution of a function
- *  - Uses the best 'setImmediate' implementation supported by the current
- *    runtime environment
- *
- * @param {function} fn - Function to execute
- *
- * --
- *
- * @note setImmediate is preferred over nextTick
- *
- * @see https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/
- */
-export const defer = set_immediate_implementation();
-
-// -----------------------------------------------------------------------------
-
-/**
- * Adds a wrapper around a function that only calls the supplied function
- * if the (first) supplied argument to the returned function is not `null`
- *
- * @param {object} [object]
- *   Optional function context to be used as `this`
- *
- * @param {function} functionOrMethodName
- *
- * @returns {function} not null wrapper function
- */
-// export function ifNotNull( /* object, functionOrMethodName */ )
-// {
-//   let fn;
-
-//   switch( arguments.length )
-//   {
-//     case 1:
-//       fn = arguments[0];
-//       expectFunction( fn, "Missing or invalid parameter [fn]" );
-//       break;
-
-//     case 2:
-//       {
-//         const object = arguments[0];
-//         const methodName = arguments[1];
-
-//         expectObject( object, "Invalid parameter [object]" );
-//         expectNotEmptyString( methodName, "Invalid parameter [methodName]" );
-
-//         fn = object[ methodName ].bind( object );
-
-//         expectFunction( fn, `Invalid method [<object>.${methodName}]` );
-//       }
-//       break;
-
-//     default:
-//       throw new Error("Invalid number of arguments");
-//   }
-
-//   return async ( value ) => {
-//     if( null !== value )
-//     {
-//       await fn( value );
-//     }
-//   };
-// }
+/**
+ * function.js
+ *
+ * @description
+ * This file contains code for working with functions
+ *
+ * @example
+ *
+ *   import { once } from "./function.js";
+ *
+ *   const sayHelloOnce = once( () => { console.log("Hello"); } );
+ *
+ *   sayHelloOnce();
+ *   sayHelloOnce();
+ *
+ * @example
+ *
+ *   import { defer } from './process.js';
+ *
+ *   defer( () => {
+ *     console.log("The execution of the function has been defered");
+ *   } );
+ */
+
+/* ------------------------------------------------------------------ Imports */
+
+import * as expect from '../expect/index.js';
+
+/* ---------------------------------------------------------------- Internals */
+
+const NEXT_TICK_MESSAGE = 'hk-next-tick';
+
+/**
+ * Detect and return the most suitable setImmediate implementation available
+ * on the current platform
+ */
+function set_immediate_implementation() {
+	if (typeof global !== 'undefined') {
+		if (undefined !== global.setImmediate) {
+			return global.setImmediate;
+		}
+	} else if (typeof window !== 'undefined') {
+		if (window.postMessage && window.addEventListener) {
+			const queue = [];
+
+			window.addEventListener(
+				'message',
+				(event) => {
+					const source = event.source;
+
+					if ((source === window || source === null) && event.data === NEXT_TICK_MESSAGE) {
+						event.stopPropagation();
+						if (queue.length > 0) {
+							const fn = queue.shift();
+							fn();
+						}
+					}
+				},
+				true
+			);
+
+			return function nextTickUsingPostMessage(fn) {
+				expect.function(fn);
+
+				queue.push(fn);
+				window.postMessage(NEXT_TICK_MESSAGE, '*');
+			};
+		}
+	}
+
+	throw new Error('No suitable [setImmediate] implementation available');
+}
+
+/* ------------------------------------------------------------------ Exports */
+
+/**
+ * 'No operation' function
+ * - A function that does nothing
+ */
+export const noop = () => {};
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Wraps a function so that the callback function will be called only once
+ *
+ * @param {function} callback
+ *
+ * @returns {function} callback wrapped in `once` function
+ */
+export function once(callback) {
+	expect.function(callback);
+
+	let ignore = false;
+
+	return function () {
+		if (!ignore) {
+			ignore = true;
+			callback(...arguments);
+		}
+	};
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Returns a debounced function
+ * - The original function is not called more than once during the
+ *   specified interval
+ *
+ * @param {function} fn
+ * @param {number} [intervalMs=200]
+ *
+ * @returns {function} debounced function
+ */
+export function debounce(fn, intervalMs = 200) {
+	let idleTimer;
+	let lastArguments;
+
+	// console.log("debounce");
+
+	return function debounced() {
+		// console.log("debounced");
+
+		if (idleTimer) {
+			// console.log("idleTimer running");
+
+			// The function has been called recently
+			lastArguments = arguments;
+			return;
+		}
+
+		idleTimer = setTimeout(() => {
+			// console.log("idleTimer finished", lastArguments);
+
+			idleTimer = null;
+
+			if (lastArguments) {
+				//
+				// At least one call has been "debounced"
+				// -> make call with last arguments, so function always receives
+				//    the arguments of the last call to the function
+				//
+				fn(...lastArguments);
+				lastArguments = undefined;
+			}
+		}, intervalMs);
+
+		fn(...arguments);
+	};
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Defer the execution of a function
+ *  - Uses the best 'setImmediate' implementation supported by the current
+ *    runtime environment
+ *
+ * @param {function} fn - Function to execute
+ *
+ * --
+ *
+ * @note setImmediate is preferred over nextTick
+ *
+ * @see https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/
+ */
+export const defer = set_immediate_implementation();
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Adds a wrapper around a function that only calls the supplied function
+ * if the (first) supplied argument to the returned function is not `null`
+ *
+ * @param {object} [object]
+ *   Optional function context to be used as `this`
+ *
+ * @param {function} functionOrMethodName
+ *
+ * @returns {function} not null wrapper function
+ */
+// export function ifNotNull( /* object, functionOrMethodName */ )
+// {
+//   let fn;
+
+//   switch( arguments.length )
+//   {
+//     case 1:
+//       fn = arguments[0];
+//       expectFunction( fn, "Missing or invalid parameter [fn]" );
+//       break;
+
+//     case 2:
+//       {
+//         const object = arguments[0];
+//         const methodName = arguments[1];
+
+//         expectObject( object, "Invalid parameter [object]" );
+//         expectNotEmptyString( methodName, "Invalid parameter [methodName]" );
+
+//         fn = object[ methodName ].bind( object );
+
+//         expectFunction( fn, `Invalid method [<object>.${methodName}]` );
+//       }
+//       break;
+
+//     default:
+//       throw new Error("Invalid number of arguments");
+//   }
+
+//   return async ( value ) => {
+//     if( null !== value )
+//     {
+//       await fn( value );
+//     }
+//   };
+// }

package/dist/util/geo/index.js

@@ -1,26 +1,26 @@
-/**
- * Check if a point lies within a polygon
- *
- * @param {number} xPct - X-coordinate as percentage
- * @param {number} yPct - Y-coordinate as percentage
- * @param {Array} polygon - Array of [x, y] points
- *
- * @returns {boolean} True if the point lies within the polygon
- */
-export function isPointInPolygon(xPct, yPct, polygon) {
-  let inside = false;
-  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-    const xi = polygon[i][0];
-    const yi = polygon[i][1];
-    const xj = polygon[j][0];
-    const yj = polygon[j][1];
-
-    const intersect =
-      yi > yPct !== yj > yPct &&
-      xPct < ((xj - xi) * (yPct - yi)) / (yj - yi) + xi;
-    if (intersect) {
-      inside = !inside;
-    }
-  }
-  return inside;
-}
+/**
+ * Check if a point lies within a polygon
+ *
+ * @param {number} xPct - X-coordinate as percentage
+ * @param {number} yPct - Y-coordinate as percentage
+ * @param {Array} polygon - Array of [x, y] points
+ *
+ * @returns {boolean} True if the point lies within the polygon
+ */
+export function isPointInPolygon(xPct, yPct, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i][0];
+    const yi = polygon[i][1];
+    const xj = polygon[j][0];
+    const yj = polygon[j][1];
+
+    const intersect =
+      yi > yPct !== yj > yPct &&
+      xPct < ((xj - xi) * (yPct - yi)) / (yj - yi) + xi;
+    if (intersect) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}

package/dist/util/index.d.ts

@@ -1,3 +1,5 @@
-export * as exceptions from "./exceptions/index.js";
+export { rethrow } from "./exceptions/index.js";
 export * as expect from "./expect/index.js";
+export * as is from "./is/index.js";
+export * as object from "./object/index.js";
 export * as singleton from "./singleton/index.js";

package/dist/util/index.js

@@ -1,3 +1,7 @@
-export * as exceptions from './exceptions/index.js';
-export * as expect from './expect/index.js';
-export * as singleton from './singleton/index.js';
+export { rethrow } from './exceptions/index.js';
+
+export * as expect from './expect/index.js';
+export * as is from './is/index.js';
+export * as object from './object/index.js';
+
+export * as singleton from './singleton/index.js';

package/dist/util/is/index.d.ts

@@ -6,15 +6,7 @@
  *
  * @return {boolean} true if the value looks like an array
  */
-export function isArrayLike(item: any): boolean;
-/**
- * Check if a value is an Arguments object
- *
- * @param {any} value
- *
- * @returns {boolean} true if the value is an Arguments object
- */
-export function isArguments(value: any): boolean;
+export function arrayLike(item: any): boolean;
 /**
  * Check if a value is an array that only contains primitives
  * - A primitive is a not-object value
@@ -23,7 +15,7 @@ export function isArguments(value: any): boolean;
  *
  * @return {boolean} true if the value is an array of primitives
  */
-export function isArrayOfPrimitives(arr: any): boolean;
+export function arrayOfPrimitives(value: any): boolean;
 /**
  * Check if the supplied value is async iterable
  * - Aync iterable objects must implement the "@@asyncIterator" method
@@ -32,7 +24,7 @@ export function isArrayOfPrimitives(arr: any): boolean;
  *
  * @returns {boolean} true if the value is async iterable
  */
-export function isAsyncIterator(value: any): boolean;
+export function asyncIterator(value: any): boolean;
 /**
  * Check if the supplied value is an async function
  * - Returns true for functions declared as "async function" or
@@ -45,7 +37,7 @@ export function isAsyncIterator(value: any): boolean;
  *
  * @returns {boolean} true if the value is an async function
  */
-export function isAsyncFunction(value: any): boolean;
+export function asyncFunction(value: any): boolean;
 /**
  * Check if the supplied value is iterable
  * - Iterable objects must implement the "@@iterator" method
@@ -55,7 +47,7 @@ export function isAsyncFunction(value: any): boolean;
  *
  * @returns {boolean} true if the value is (not async) iterable
  */
-export function isIterable(value: any): boolean;
+export function iterable(value: any): boolean;
 /**
  * Check if the supplied value is an object bu not a promise
  * - Promises return false
@@ -65,4 +57,13 @@ export function isIterable(value: any): boolean;
  *
  * @returns {boolean} true if the value is an Object, but not a Promise
  */
-export function isObject(value: any): boolean;
+export function object(value: any): boolean;
+export { argumentsCheck as arguments };
+/**
+ * Check if a value is an Arguments object
+ *
+ * @param {any} value
+ *
+ * @returns {boolean} true if the value is an Arguments object
+ */
+declare function argumentsCheck(value: any): boolean;