@hkdigital/lib-sveltekit 0.0.42 → 0.0.45

package/README.md

@@ -40,7 +40,7 @@ All exports are in subfolders.
 For example to import a constant from `constants/regexp/index.js`
 
 ```svelte
-import { CHAR } from '@hkdigital/lib-sveltekit-test/constants/regexp';
+import { CHAR } from '@hkdigital/lib-sveltekit/constants/regexp';
 ```
 
 ### Import CSS
@@ -51,7 +51,7 @@ For example:
 
 ```css
 /* src/app.css */
-@import '../node_modules/@hkdigital/lib-sveltekit-test/dist/css/utilities.postcss';
+@import '../node_modules/@hkdigital/lib-sveltekit/dist/css/utilities.postcss';
 ```
 
 ### Enable tailwind processing

package/dist/classes/data/IterableTree.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @typedef {object} Options
+ * @property {boolean} walkArrays
+ * @property {boolean} ignoreEmptyObjectLeaves
+ * @property {boolean} expandPathKeys
+ * @property {boolean} outputIntermediateNodes
+ */
+export default class IterableTree {
+    /**
+     * Construct an object that can be used to iterate paths and values in
+     * an object.
+     * - Returns path-value pairs for all leaves of the object (tree)
+     * - Iterates "own properties" only (not inherited properties)
+     *
+     * @param {object} obj - Object to iterate
+     * @param {Options} [options]
+     * @param {string[]} [_parentArrPath]
+     *
+     *
+     * @return {Iterator} iterable object
+     */
+    constructor(obj: object, options?: Options, _parentArrPath?: string[]);
+    obj: any;
+    _parentArrPath: string[];
+    /**
+     * Get an iterator to iterate over all object [ path, value ] entries
+     *
+     * @returns {Iterator} object entries iterator
+     */
+    entries(): Iterator<any, any, any>;
+    /**
+     * Get an iterator to iterate over all object paths
+     *
+     * @returns {Iterator} object path iterator
+     */
+    paths(): Iterator<any, any, any>;
+    /**
+     * Get an iterator to iterate over all values at the leaves of the paths in
+     * the object
+     *
+     * @returns {Iterator} object value iterator
+     */
+    values(): Iterator<any, any, any>;
+    #private;
+}
+export type Options = {
+    walkArrays: boolean;
+    ignoreEmptyObjectLeaves: boolean;
+    expandPathKeys: boolean;
+    outputIntermediateNodes: boolean;
+};

package/dist/classes/data/IterableTree.js

@@ -0,0 +1,243 @@
+/* ------------------------------------------------------------------ Imports */
+
+import * as expect from '../../util/expect/index.js';
+
+import { PATH_SEPARATOR } from '../../util/object/index.js';
+
+/* ------------------------------------------------------------------ Typedef */
+
+/**
+ * @typedef {object} Options
+ * @property {boolean} walkArrays
+ * @property {boolean} ignoreEmptyObjectLeaves
+ * @property {boolean} expandPathKeys
+ * @property {boolean} outputIntermediateNodes
+ */
+
+/* ------------------------------------------------------------------ Exports */
+
+export default class IterableTree {
+	/**
+	 * @type {Options}
+	 */
+	#options;
+
+	/**
+	 * Construct an object that can be used to iterate paths and values in
+	 * an object.
+	 * - Returns path-value pairs for all leaves of the object (tree)
+	 * - Iterates "own properties" only (not inherited properties)
+	 *
+	 * @param {object} obj - Object to iterate
+	 * @param {Options} [options]
+	 * @param {string[]} [_parentArrPath]
+	 *
+	 *
+	 * @return {Iterator} iterable object
+	 */
+	constructor(obj, options, _parentArrPath) {
+		//super( ...arguments );
+
+		expect.object(obj);
+
+		this.obj = obj;
+
+		this.#options = Object.assign(
+			{
+				walkArrays: false,
+				ignoreEmptyObjectLeaves: false,
+				expandPathKeys: false,
+				outputIntermediateNodes: false
+			},
+			options
+		);
+
+		this._parentArrPath = _parentArrPath || null;
+	}
+
+	/* --------------------------------------------------------- Public methods */
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get an iterator to iterate over all object [ path, value ] entries
+	 *
+	 * @returns {Iterator} object entries iterator
+	 */
+	*entries() {
+		const obj = this.obj;
+		const parentArrPath = this._parentArrPath;
+
+		const options = this.options;
+
+		let { expandPathKeys, ignoreEmptyObjectLeaves, outputIntermediateNodes } = this.#options;
+
+		if (parentArrPath) {
+			// Never expand keys if not in root object
+			expandPathKeys = false;
+		}
+
+		// @note keys are own properties only
+		const keys = Object.keys(obj);
+
+		let pathKeys;
+
+		if (expandPathKeys) {
+			pathKeys = [];
+		}
+
+		// -- STEP 1: Normal object iteration (and gather path keys)
+
+		for (let j = 0, n = keys.length; j < n; j = j + 1) {
+			const key = keys[j];
+
+			if (expandPathKeys && key.includes(PATH_SEPARATOR)) {
+				// Gather pathKeys
+				pathKeys.push(key);
+				continue;
+			}
+
+			const valueAtPath = obj[key];
+
+			if (undefined === valueAtPath) {
+				// Ignore path-value pair if valueAtPath is undefined
+				continue;
+			}
+
+			let path;
+
+			if (parentArrPath) {
+				path = parentArrPath.slice(0);
+				path.push(key);
+			} else {
+				path = [key];
+			}
+
+			// No recursion >>
+
+			if (!this.#shouldRecurse(valueAtPath)) {
+				if (
+					ignoreEmptyObjectLeaves &&
+					valueAtPath instanceof Object &&
+					0 === Object.keys(valueAtPath).length
+				) {
+					// Ignore empty object leave
+					continue;
+				}
+
+				yield [path, valueAtPath];
+				continue;
+			}
+
+			// Recursion >>
+
+			// console.log( { path, valueAtPath, outputIntermediateNodes } );
+
+			if (outputIntermediateNodes) {
+				// outputIntermediateNodes=true
+				// -> Output itermediate node
+
+				if (Array.isArray(valueAtPath)) {
+					// Intermediate node is an array
+					yield [path, []];
+				} else {
+					// Intermediate node is plain object
+					yield [path, {}];
+				}
+			}
+
+			const objectIterator = new IterableTree(valueAtPath, options, path);
+
+			for (const entry of objectIterator.entries()) {
+				yield entry;
+			}
+		} // end for
+
+		// -- STEP 2: Output entries from "path keys"
+
+		if (!pathKeys || !pathKeys.length) {
+			// No path keys -> done
+			return;
+		}
+
+		for (let j = 0, n = pathKeys.length; j < n; j = j + 1) {
+			// @note path keys do not output intermediate nodes
+
+			const key = pathKeys[j];
+
+			const valueAtPath = obj[key];
+			const path = key.split(PATH_SEPARATOR);
+
+			yield [path, valueAtPath];
+		}
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get an iterator to iterate over all object paths
+	 *
+	 * @returns {Iterator} object path iterator
+	 */
+	*paths() {
+		for (const entry of this.entries()) {
+			yield entry[0];
+		}
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get an iterator to iterate over all values at the leaves of the paths in
+	 * the object
+	 *
+	 * @returns {Iterator} object value iterator
+	 */
+	*values() {
+		for (const entry of this.entries()) {
+			yield entry[1];
+		}
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Returns true if the iterator should recurse into the specified value
+	 *
+	 * @param {string} value
+	 *
+	 * @return {boolean} true if the value should be iterated
+	 */
+	#shouldRecurse(value) {
+		if (!(value instanceof Object)) {
+			// not an object -> no recursion
+			return false;
+		}
+
+		const walkArrays = this.#options.walkArrays;
+
+		if (walkArrays && Array.isArray(value)) {
+			// walkArrays=true AND isArray
+
+			if (!value.length) {
+				// Array is empty -> no recursion
+				return false;
+			}
+
+			return true;
+		}
+
+		if ('[object Object]' !== value.toString()) {
+			// Not a plain object -> no recursion
+			return false;
+		}
+
+		if (Object.keys(value).length) {
+			// Object is not empty -> recursion
+			return true;
+		}
+
+		// Otherwise -> no recursion
+		return false;
+	}
+} // end class

package/dist/classes/data/Selector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Construct a Selector class
+ */
+export default class Selector {
+    /**
+     * Constructor
+     *
+     * @param {object|null} selector
+     */
+    constructor(selector: object | null);
+    /**
+     * Returns the first item from the list of items that matches the selector
+     *
+     * @param {object[]|null} items
+     *
+     * @returns {object|null} item or null if not found
+     */
+    findFirst(items: object[] | null): object | null;
+    /**
+     * Returns all items from the list of items that match the selector
+     *
+     * @param {object[]|null} items
+     *
+     * @returns {object|null} item or null if not found
+     */
+    findAll(items: object[] | null): object | null;
+    #private;
+}

package/dist/classes/data/Selector.js

@@ -0,0 +1,188 @@
+/**
+ * Selector.js
+ *
+ * @description
+ * This file contains a class that can be used to select items from lists of
+ * objects.
+ *
+ * @TODO
+ * Allow other selection criteria than exact key-value pair matches
+ *
+ * @example
+ *
+ *   import Selector from "./Selector.js";
+ *
+ *   const selector = new Selector( { age: 42 } );
+ *
+ *   const items =
+ *     [
+ *       { name: "Maria", age: 41 },
+ *       { name: "John",  age: 42 },
+ *       { name: "Max", age: 43 }
+ *     ]
+ *
+ *   const item = selector.findFirst( items );
+ *
+ *   console.log( item );
+ */
+
+/* ------------------------------------------------------------------ Imports */
+
+import * as expect from '../../util/expect/index.js';
+
+/* ------------------------------------------------------------------- Export */
+
+/**
+ * Construct a Selector class
+ */
+export default class Selector {
+	/** @type {function|null} test function */
+	#testFn = null;
+
+	/**
+	 * Constructor
+	 *
+	 * @param {object|null} selector
+	 */
+	constructor(selector) {
+		this.#updateTestFn(selector);
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Returns the first item from the list of items that matches the selector
+	 *
+	 * @param {object[]|null} items
+	 *
+	 * @returns {object|null} item or null if not found
+	 */
+	findFirst(items) {
+		if (!items) {
+			return null;
+		}
+
+		for (const item of items) {
+			if (this.#testFn(item)) {
+				return item;
+			}
+		}
+
+		return null;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Returns all items from the list of items that match the selector
+	 *
+	 * @param {object[]|null} items
+	 *
+	 * @returns {object|null} item or null if not found
+	 */
+	findAll(items) {
+		const result = [];
+
+		if (!items) {
+			return result;
+		}
+
+		for (const item of items) {
+			if (this.#testFn(item)) {
+				result.push(item);
+			}
+		}
+
+		return result;
+	}
+
+	/* ------------------------------------------------------- Internal methods */
+
+	/**
+	 * Update the internal selector function
+	 */
+	#updateTestFn(selector) {
+		// > Case A: selector=null
+
+		if (null === selector) {
+			this.#testFn = this.#returnTrue;
+			return;
+		}
+
+		// > Validate selector
+
+		expect.objectOrNull(selector);
+
+		const keys = Object.keys(selector);
+		const n = keys.length;
+
+		// > Case B: selector has not properties
+
+		if (!n) {
+			this.#testFn = this.#returnTrue;
+			return;
+		}
+
+		// > Case C: selector with single key-value pair
+
+		if (1 === n) {
+			const key = keys[0];
+			const value = selector[key];
+
+			this.#testFn = this.#testKeyValue.bind(this, key, value);
+		}
+
+		// > Case D: selector with multiple key-value pairs
+
+		const selectorValues = [];
+
+		for (const key of keys) {
+			selectorValues.push(selector[key]);
+		}
+
+		this.#testFn = this.#testMultipleKeyValues.bind(this, keys, selectorValues);
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Always return true
+	 * - This function is used if the test function should always return true
+	 *
+	 * @returns {boolean} true
+	 */
+	#returnTrue() {
+		return true;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Return true if the item matches the key-value pair
+	 * - This function is used if the test function should test a
+	 *   single key-value pair
+	 */
+	#testKeyValue(key, value, item) {
+		return value === item[key];
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Return true if the item matches all key-value pairs
+	 * - This function is used if the test function should test multiple
+	 *   key-value pairs
+	 */
+	#testMultipleKeyValues(keys, values, item) {
+		let isMatch = true;
+
+		for (let j = 0, n = keys.length; j < n; j = j + 1) {
+			if (values[j] !== item[keys[j]]) {
+				isMatch = false;
+				break;
+			}
+		} // end for
+
+		return isMatch;
+	}
+} // end class

package/dist/classes/data/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Selector } from "./Selector.js";
+export { default as IterableTree } from "./IterableTree.js";

package/dist/classes/data/index.js

@@ -0,0 +1,2 @@
+export { default as Selector } from './Selector.js';
+export { default as IterableTree } from './IterableTree.js';

package/dist/classes/index.d.ts

@@ -1,2 +1,3 @@
+export * as data from "./data/index.js";
 export * as streams from "./streams/index.js";
 export * as stores from "./stores/index.js";

package/dist/classes/index.js

@@ -1,2 +1,3 @@
+export * as data from './data/index.js';
 export * as streams from './streams/index.js';
 export * as stores from './stores/index.js';

package/dist/components/input/HkInputField.svelte

@@ -0,0 +1,49 @@
+<script>
+  /**
+   *
+   * @type {{
+   *   legendTitle: string,
+   *   error?: boolean,
+   *   name?: string,
+   *   type: string,
+   *   placeholder: string,
+   *   classes?: string,
+   *   requiredBoolean: boolean,
+   *   warningSymbol: string,
+   *   fieldClasses?: string,
+   *   legendClasses?: string
+   * }}
+   *
+   */
+  let 
+  { 
+    legendTitle, 
+    type, 
+    placeholder, 
+    error, 
+    name,
+    requiredBoolean,
+    warningSymbol,
+    classes,
+    fieldClasses,
+    legendClasses
+  } = $props();
+
+</script>
+
+<fieldset
+  data-hk-input-field
+  class="flex w-full items-center rounded {fieldClasses}"
+>
+  <legend class="px-2 {legendClasses}" class:error>{legendTitle}</legend>
+  <input
+    class='w-full border-none bg-transparent {classes}'
+    {type}
+    {placeholder}
+    {name}
+    required={requiredBoolean}
+  />
+  {#if error}
+    <img src={warningSymbol} class="mb-2 mr-8" alt="Warning symbol" />
+  {/if}
+</fieldset>

package/dist/components/input/HkInputField.svelte.d.ts

@@ -0,0 +1,13 @@
+export default HkInputField;
+declare const HkInputField: import("svelte").Component<{
+    legendTitle: string;
+    error?: boolean;
+    name?: string;
+    type: string;
+    placeholder: string;
+    classes?: string;
+    requiredBoolean: boolean;
+    warningSymbol: string;
+    fieldClasses?: string;
+    legendClasses?: string;
+}, {}, "">;

package/dist/components/input/index.d.ts

@@ -0,0 +1 @@
+export { default as HkInputField } from "./HkInputField.svelte";

package/dist/components/input/index.js

@@ -0,0 +1 @@
+export { default as HkInputField } from './HkInputField.svelte';

package/dist/index.js

@@ -4,6 +4,6 @@
 // @see package.json > exports
 //
 // @example
-// import { TimeStampSource } from '@hkdigital/lib-sveltekit-test/classes';
+// import { TimeStampSource } from '@hkdigital/lib-sveltekit/classes';
 //
 //