@hkdigital/lib-sveltekit 0.0.31

package/dist/util/expect/index.js

@@ -0,0 +1,145 @@
+/**
+ * Validation functions that can be used as safe guards in your code
+ *
+ * @example
+ *
+ * import * as expect from '<path>/expect.js';
+ *
+ * function logText( text )
+ * {
+ *   expect.string( text );
+ *   expect.true( 1 > 0 );
+ *
+ *   console.log( text );
+ * }
+ *
+ * logText( 'Hello' );
+ * logText( 123 );      // <- Will throw an exception
+ */
+
+import * as v from 'valibot';
+
+/** Reusable schema's */
+
+// const StringSchema = v.string();
+// const FunctionSchema = v.function();
+
+/** Exports */
+
+// > Primitives
+
+/**
+ * Throws a validation error if value is not a string
+ *
+ * @param {*} value
+ */
+export function string(value) {
+  v.parse(v.string(), value);
+}
+
+// boolean
+// number
+// symbol
+// defined
+
+// > Base objects
+
+// object
+
+// array
+
+/**
+ * Throws a validation error if value is not an array of strings
+ *
+ * @param {*} value
+ */
+export function stringArray(value) {
+  v.parse(v.array(v.string()), value);
+}
+
+/**
+ * Throws a validation error if value is not an array of objects
+ *
+ * @param {*} value
+ */
+export function objectArray(value) {
+  v.parse(v.array(v.looseObject({})), value);
+}
+
+/**
+ * Throws a validation error if value is not a function
+ *
+ * @param {*} value
+ */
+function _function(value) {
+  v.parse(v.function(), value);
+}
+
+export { _function as function };
+
+export { _function as class };
+
+// promise
+// map
+// set
+// error
+
+// > Common values
+
+// notNull
+
+/**
+ * Expect a value to be a boolean and true
+ *
+ * @param {*} value
+ */
+export function _true(value) {
+  v.value(true, value);
+}
+
+export { _true as true };
+
+// > Compounds
+
+// positiveNumber
+// notNegativeNumber
+// positiveInteger
+// notNegativeInteger
+
+// stringOrNull
+// stringOrUndefined
+
+/**
+ * Throws a validation error if value is not a string
+ *
+ * @param {*} value
+ */
+export function notEmptyString(value) {
+  const schema = v.pipe(v.string(), v.minLength(1));
+
+  v.parse(schema, value);
+}
+
+// notEmptyStringOrNull
+
+// asyncIterator
+// iterable
+// iterator
+
+// store
+
+// notEmptyArray
+// arrayLike
+// ArrayBuffer
+// ArrayOfStrings
+// arrayOrUndefined
+// arangoCollectionId
+// uriComponent
+// objectNoArray
+// objectNoFunction
+// objectOrNull
+// objectOrUndefined
+// objectPath
+// arrayOrSet
+// setOfStrings
+// emptyStringOrSymbol

package/dist/util/function.js__

@@ -0,0 +1,150 @@
+/**
+ * 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();
+ */
+
+/* ------------------------------------------------------------------ Imports */
+
+import * as Types from '$lib/typedef/base.js';
+
+/* ------------------------------------------------------------------ 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) {
+  Types.Number(callback);
+
+  expectFunction(callback, 'Missing or invalid parameter [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);
+  };
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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/index.d.ts

@@ -0,0 +1,2 @@
+export * as expect from "./expect/index.js";
+export * as singleton from "./singleton/index.js";

package/dist/util/index.js

@@ -0,0 +1,2 @@
+export * as expect from './expect/index.js';
+export * as singleton from './singleton/index.js';

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

@@ -0,0 +1,34 @@
+/**
+ * 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 {*} _.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 }: {
+    class: any;
+    args?: any[];
+    needle?: string;
+}): any;
+/**
+ * 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<T>({ class: Class, args }: {
+    class: new () => T;
+    args?: any[];
+}): T & {
+    init: () => null;
+};

package/dist/util/singleton/index.js

@@ -0,0 +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 {*} _.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/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export * as observe from "./observe/index.js";
+export * as stateContext from "./state-context/index.js";

package/dist/util/svelte/index.js

@@ -0,0 +1,2 @@
+export * as observe from './observe/index.js';
+export * as stateContext from './state-context/index.js';

package/dist/util/svelte/observe/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {function} target
+ * @param {(entries:ResizeObserverEntry[]) => void} callback
+ * @param {object} [options]
+ *
+ * @returns {{ stop: () => void }}
+ */
+export function useResizeObserver(target: Function, callback: (entries: ResizeObserverEntry[]) => void, options?: object): {
+    stop: () => void;
+};

package/dist/util/svelte/observe/index.js

@@ -0,0 +1,49 @@
+import { onMount, onDestroy } from 'svelte';
+
+/**
+ * @param {function} target
+ * @param {(entries:ResizeObserverEntry[]) => void} callback
+ * @param {object} [options]
+ *
+ * @returns {{ stop: () => void }}
+ */
+export function useResizeObserver(target, callback, options) {
+	/** @type {HTMLInputElement} */
+	let elem;
+
+	/** @type {ResizeObserver|undefined} */
+	let resizeObserver;
+
+	onMount(() => {
+		// console.log('useResizeObserver:onMount');
+
+		if (target instanceof HTMLInputElement) {
+			elem = target;
+		} else if (typeof target === 'function') {
+			let output = target();
+
+			// console.log({ output });
+
+			elem = output;
+		} else {
+			throw new Error('Invalid value for parameter [target]');
+		}
+
+		resizeObserver = new ResizeObserver(callback);
+
+		resizeObserver.observe(elem);
+	});
+
+	onDestroy(() => {
+		// console.log('useResizeObserver:onDestroy');
+
+		if (resizeObserver) {
+			resizeObserver.unobserve(elem);
+			resizeObserver = undefined;
+		}
+	});
+
+	return {
+		stop: () => {}
+	};
+}

package/dist/util/svelte/state-context/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Define a state context:
+ * - Returns a function 'createOrGetState' that can be used to create a new state
+ *   or get an existing one
+ * - Returns a function 'createState' that can be used to create a new state
+ *
+ * @template T
+ *
+ * @param {new() => T} State - Class that can be used to construct the state
+ *
+ * @returns {[
+ *   createOrGetState,
+ *   createState,
+ *   getState
+ * ]}
+ */
+export function defineStateContext<T>(State: new () => T): [(instanceKey?: string | Symbol) => T, (instanceKey?: string | Symbol) => T, (instanceKey?: string | Symbol) => T];

package/dist/util/svelte/state-context/index.js

@@ -0,0 +1,83 @@
+import { setContext, getContext, hasContext } from 'svelte';
+
+/* ----------------------------------------------------------- Create and Get */
+
+/**
+ * Define a state context:
+ * - Returns a function 'createOrGetState' that can be used to create a new state
+ *   or get an existing one
+ * - Returns a function 'createState' that can be used to create a new state
+ *
+ * @template T
+ *
+ * @param {new() => T} State - Class that can be used to construct the state
+ *
+ * @returns {[
+ *   createOrGetState,
+ *   createState,
+ *   getState
+ * ]}
+ */
+export function defineStateContext(State) {
+  const description = State.name;
+
+  const sharedKey = Symbol(description);
+
+  /**
+   * Create component state
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function createState(instanceKey) {
+    const key = instanceKey ?? sharedKey;
+
+    // console.log('Create state', key);
+
+    const state = new State();
+
+    // @ts-ignore
+    state._instanceKey = instanceKey;
+
+    return setContext(key, state);
+  }
+
+  /**
+   * Get component state or create a new state if it does not yet exist
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function createOrGetState(instanceKey) {
+    let key = instanceKey ?? sharedKey;
+
+    if (!hasContext(key)) {
+      return createState(key);
+    }
+
+    return getContext(key);
+  }
+
+  /**
+   * Get component state
+   *
+   * @throws Will throw an error if the state-context does not exist
+   *
+   * @param {string|Symbol} [instanceKey]
+   *
+   * @returns {T} state
+   */
+  function getState(instanceKey) {
+    let key = instanceKey ?? sharedKey;
+
+    if (!hasContext(key)) {
+      throw new Error(`No state context found. Create one first`);
+    }
+
+    return getContext(key);
+  }
+
+  return [createOrGetState, createState, getState];
+}