@hkdigital/lib-core 0.3.9 → 0.3.11

package/dist/util/singleton/index.js

@@ -1,97 +1,97 @@
-import { expect } from '../index.js';
-
-const instancesByNeedle = new Map();
-
-/**
- * Get a singleton instance
- * - A class can be supplied to create the singleton instance from
- * - The singleton is identified by a needle string
- *
- * @param {object} _
- * @param {any} _.class
- * @param {*[]} [_.args] - Constructor arguments
- * @param {string} [_.needle]
- *   If not supplied, a needle will be constructed from the serialized
- *   constructor arguments (args).
- */
-export function getInstance({ needle, class: Class, args }) {
-	expect.class(Class);
-
-	if (!needle) {
-		// Stringify instance arguments and use it as needle
-		needle = JSON.stringify(args === undefined ? null : args);
-	}
-
-	expect.notEmptyString(needle);
-
-	const className = Class.constructor.name;
-
-	// console.log('getInstance()', { needle, args, className });
-
-	needle = `${className}:${needle}`;
-
-	let instance = instancesByNeedle.get(needle);
-
-	if (!instance) {
-		// console.log('Create new instance');
-		// @ts-ignore
-		instance = new Class(...(args ?? []));
-
-		instancesByNeedle.set(needle, instance);
-	}
-
-	return instance;
-}
-
-/**
- * Creates a proxy that instantiates the singleton class upon it's first usage
- *
- * @template T
- *
- * @param {object} _
- * @param {new() => T} _.class
- * @param {*[]} [_.args] - Constructor arguments
- *
- * @returns {T & {init:()=>null}} proxy
- */
-export function lazySingleton({ class: Class, args }) {
-	/** @type {T} */
-	let singleton;
-
-	/** @type {T & {init:()=>null}} */
-	// @ts-ignore
-	const proxy = new Proxy(
-		// @ts-ignore
-		{},
-		{
-			/**
-			 * @param {T} target
-			 * @param {string} prop
-			 */
-			// @ts-ignore
-			get(target, prop) {
-				// console.log('lazySingleton: get property', prop);
-
-				if (!singleton) {
-					// @ts-ignore
-					singleton = new Class(...(args ?? []));
-				}
-
-				if (prop === 'init') {
-					// @ts-ignore
-					if (prop in singleton) {
-						// The class has an init method itself, return a reference
-						return singleton[prop];
-					}
-
-					return () => null;
-				}
-
-				// @ts-ignore
-				return singleton[prop];
-			}
-		}
-	);
-
-	return proxy;
-}
+import { expect } from '../index.js';
+
+const instancesByNeedle = new Map();
+
+/**
+ * Get a singleton instance
+ * - A class can be supplied to create the singleton instance from
+ * - The singleton is identified by a needle string
+ *
+ * @param {object} _
+ * @param {any} _.class
+ * @param {*[]} [_.args] - Constructor arguments
+ * @param {string} [_.needle]
+ *   If not supplied, a needle will be constructed from the serialized
+ *   constructor arguments (args).
+ */
+export function getInstance({ needle, class: Class, args }) {
+	expect.class(Class);
+
+	if (!needle) {
+		// Stringify instance arguments and use it as needle
+		needle = JSON.stringify(args === undefined ? null : args);
+	}
+
+	expect.notEmptyString(needle);
+
+	const className = Class.constructor.name;
+
+	// console.log('getInstance()', { needle, args, className });
+
+	needle = `${className}:${needle}`;
+
+	let instance = instancesByNeedle.get(needle);
+
+	if (!instance) {
+		// console.log('Create new instance');
+		// @ts-ignore
+		instance = new Class(...(args ?? []));
+
+		instancesByNeedle.set(needle, instance);
+	}
+
+	return instance;
+}
+
+/**
+ * Creates a proxy that instantiates the singleton class upon it's first usage
+ *
+ * @template T
+ *
+ * @param {object} _
+ * @param {new() => T} _.class
+ * @param {*[]} [_.args] - Constructor arguments
+ *
+ * @returns {T & {init:()=>null}} proxy
+ */
+export function lazySingleton({ class: Class, args }) {
+	/** @type {T} */
+	let singleton;
+
+	/** @type {T & {init:()=>null}} */
+	// @ts-ignore
+	const proxy = new Proxy(
+		// @ts-ignore
+		{},
+		{
+			/**
+			 * @param {T} target
+			 * @param {string} prop
+			 */
+			// @ts-ignore
+			get(target, prop) {
+				// console.log('lazySingleton: get property', prop);
+
+				if (!singleton) {
+					// @ts-ignore
+					singleton = new Class(...(args ?? []));
+				}
+
+				if (prop === 'init') {
+					// @ts-ignore
+					if (prop in singleton) {
+						// The class has an init method itself, return a reference
+						return singleton[prop];
+					}
+
+					return () => null;
+				}
+
+				// @ts-ignore
+				return singleton[prop];
+			}
+		}
+	);
+
+	return proxy;
+}

package/dist/util/string/array-path.js

@@ -1,75 +1,75 @@
-import { PATH_SEPARATOR } from '../object/index.js';
-
-/**
- * Convert a path string to an array path
- * - The path string will be spit at the `pathSeparator` token
- * - If the supplied path is already an array, the original array will
- *   be returned
- *
- * @param {string|string[]} path
- *   String or array path (e.g. "some.path.to")
- *
- * @param {string} [pathSeparator=PATH_SEPARATOR]
- *   A custom path separator to use instead of the default "."
- *
- * @returns {string} string path (e.g. "some.path.to")
- */
-export function toStringPath(path, pathSeparator = PATH_SEPARATOR) {
-  if (Array.isArray(path)) {
-    return path.join(pathSeparator);
-  } else if (typeof path === 'string') {
-    // path is already a string
-    return path;
-  } else {
-    throw new Error(
-      'Missing or invalid parameter [path] (expected string or array)'
-    );
-  }
-}
-
-// -----------------------------------------------------------------------------
-
-/**
- * Make sure that the outputted path is an array path
- * - The input value may be a array path
- * - The input value may be a string path (no conversion needed)
- *
- * @param {string|string[]} path
- *
- * @returns {string[]} array path (list of strings)
- */
-// export function fromPath( path )
-// {
-//   if( typeof path === "string" )
-//   {
-//     return path;
-//   }
-//   else {
-//     expect.array( path,
-//       "Missing or invalid parameter [path] (expected string or string[])" );
-
-//     let strPath = proc.arrayToStringPathWeakMap.get( path );
-
-//     if( strPath )
-//     {
-//       // std.debug( "Using cached value", path );
-//       return strPath;
-//     }
-
-//     // Check array path
-//     for( let j = 0, n = path.length; j < n; j = j + 1 )
-//     {
-//       if( typeof path[j] !== "string" )
-//       {
-//         throw new Error("Invalid array path. Expected array of strings");
-//       }
-//     }
-
-//     strPath = path.join("/");
-
-//     proc.safeArrayPathsWeakMap.set( path, true );
-//     proc.arrayToStringPathWeakMap.set( path, strPath );
-
-//     return strPath;
-//   }
-// }
+import { PATH_SEPARATOR } from '../object/index.js';
+
+/**
+ * Convert a path string to an array path
+ * - The path string will be spit at the `pathSeparator` token
+ * - If the supplied path is already an array, the original array will
+ *   be returned
+ *
+ * @param {string|string[]} path
+ *   String or array path (e.g. "some.path.to")
+ *
+ * @param {string} [pathSeparator=PATH_SEPARATOR]
+ *   A custom path separator to use instead of the default "."
+ *
+ * @returns {string} string path (e.g. "some.path.to")
+ */
+export function toStringPath(path, pathSeparator = PATH_SEPARATOR) {
+  if (Array.isArray(path)) {
+    return path.join(pathSeparator);
+  } else if (typeof path === 'string') {
+    // path is already a string
+    return path;
+  } else {
+    throw new Error(
+      'Missing or invalid parameter [path] (expected string or array)'
+    );
+  }
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Make sure that the outputted path is an array path
+ * - The input value may be a array path
+ * - The input value may be a string path (no conversion needed)
+ *
+ * @param {string|string[]} path
+ *
+ * @returns {string[]} array path (list of strings)
+ */
+// export function fromPath( path )
+// {
+//   if( typeof path === "string" )
+//   {
+//     return path;
+//   }
+//   else {
+//     expect.array( path,
+//       "Missing or invalid parameter [path] (expected string or string[])" );
+
+//     let strPath = proc.arrayToStringPathWeakMap.get( path );
+
+//     if( strPath )
+//     {
+//       // std.debug( "Using cached value", path );
+//       return strPath;
+//     }
+
+//     // Check array path
+//     for( let j = 0, n = path.length; j < n; j = j + 1 )
+//     {
+//       if( typeof path[j] !== "string" )
+//       {
+//         throw new Error("Invalid array path. Expected array of strings");
+//       }
+//     }
+
+//     strPath = path.join("/");
+
+//     proc.safeArrayPathsWeakMap.set( path, true );
+//     proc.arrayToStringPathWeakMap.set( path, strPath );
+
+//     return strPath;
+//   }
+// }

package/dist/util/string/convert.js

@@ -1,54 +1,54 @@
-import * as expect from '../expect/index.js';
-
-/**
- * Remove strange characters from a string and replace whitespace by
- * dashes.
- *
- * @returns {string} string that can be used as uri
- */
-export function toUriName(str) {
-  expect.string(str);
-
-  str = str.toLowerCase().replace(/[^a-z0-9]+/gi, '-');
-
-  // TODO: remove duplicate dashes
-
-  return str;
-}
-
-/**
- * Captizalize the first character of a string
- *
- * @param {string} str - Input string
- *
- * @returns {string} string with first letter capitalized
- */
-export function capitalizeFirst(str) {
-  if (!str.length) {
-    return str;
-  }
-
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-/**
- * Converts a kebab-case string to Title Case.
- *
- * @param {string} kebabString - The kebab-case string to convert
- * @return {string} The converted Title Case string
- */
-export function kebabToTitleCase(kebabString) {
-  // Check if input is a string
-  if (typeof kebabString !== 'string') {
-    throw new Error('Input must be a string');
-  }
-
-  // Split the string by hyphens
-  return kebabString
-    .split('-')
-    .map((word) => {
-      // Capitalize the first letter of each word
-      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-    })
-    .join(' ');
-}
+import * as expect from '../expect/index.js';
+
+/**
+ * Remove strange characters from a string and replace whitespace by
+ * dashes.
+ *
+ * @returns {string} string that can be used as uri
+ */
+export function toUriName(str) {
+  expect.string(str);
+
+  str = str.toLowerCase().replace(/[^a-z0-9]+/gi, '-');
+
+  // TODO: remove duplicate dashes
+
+  return str;
+}
+
+/**
+ * Captizalize the first character of a string
+ *
+ * @param {string} str - Input string
+ *
+ * @returns {string} string with first letter capitalized
+ */
+export function capitalizeFirst(str) {
+  if (!str.length) {
+    return str;
+  }
+
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Converts a kebab-case string to Title Case.
+ *
+ * @param {string} kebabString - The kebab-case string to convert
+ * @return {string} The converted Title Case string
+ */
+export function kebabToTitleCase(kebabString) {
+  // Check if input is a string
+  if (typeof kebabString !== 'string') {
+    throw new Error('Input must be a string');
+  }
+
+  // Split the string by hyphens
+  return kebabString
+    .split('-')
+    .map((word) => {
+      // Capitalize the first letter of each word
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join(' ');
+}