@hkdigital/lib-core 0.3.15 → 0.4.3

package/dist/ui/dev.js

@@ -0,0 +1,3 @@
+export { default as CheckButton } from './dev/buttons/CheckButton.svelte';
+export { default as TextBlock } from './dev/blocks/TextBlock.svelte';
+export { default as DebugPanelDesignScaling } from './dev/debug-panel-design-scaling/DebugPanelDesignScaling.svelte';

package/dist/ui/primitives/buttons/button/Button.svelte.d.ts

@@ -41,4 +41,4 @@ declare const Button: import("svelte").Component<{
     snippetLoading?: import("svelte").Snippet;
     snippetError?: import("svelte").Snippet;
     children: import("svelte").Snippet;
-}, {}, "error" | "loading" | "disabled" | "selected" | "active">;
+}, {}, "error" | "disabled" | "loading" | "selected" | "active">;

package/dist/ui/primitives/typedef.d.ts

@@ -0,0 +1 @@
+export * from "./icons/typedef.js";

package/dist/ui/primitives/typedef.js

@@ -0,0 +1 @@
+export * from './icons/typedef.js';

package/dist/ui/primitives.d.ts

@@ -0,0 +1,5 @@
+export * from "./primitives/area/index.js";
+export * from "./primitives/buttons/index.js";
+export * from "./primitives/icons/index.js";
+export * from "./primitives/inputs/index.js";
+export * from "./primitives/panels/index.js";

package/dist/ui/primitives.js

@@ -0,0 +1,5 @@
+export * from './primitives/area/index.js';
+export * from './primitives/buttons/index.js';
+export * from './primitives/icons/index.js';
+export * from './primitives/inputs/index.js';
+export * from './primitives/panels/index.js';

package/dist/ui/typedef.d.ts

@@ -0,0 +1,2 @@
+export * from "./components/typedef.js";
+export * from "./primitives/typedef.js";

package/dist/ui/typedef.js

@@ -0,0 +1,2 @@
+export * from './components/typedef.js';
+export * from './primitives/typedef.js';

package/dist/util/array/index.js

@@ -6,7 +6,7 @@ import { smallestFirst, largestFirst } from '../compare/index.js';
 
 import { objectGet, PATH_SEPARATOR } from '../object/index.js';
 
-import Selector from '../../classes/data/Selector.js';
+import { Selector } from '../../generic/data.js';
 
 /* ---------------------------------------------------------------- Internals */
 

package/dist/util/bases/base58.d.ts

@@ -19,13 +19,13 @@ export function isBase58(str: string): boolean;
  *
  * @param {string} str - String to decode
  *
- * @param {number} [exceptionValue]
+ * @param {bigint} [exceptionValue]
  *   If specified, the exceptionValue will be returned instead of
  *   throwing an exception
  *
- * @returns {number} decoded decimal numerical representation
+ * @returns {bigint} decoded decimal numerical representation
  */
-export function base58toNumber(str: string, exceptionValue?: number, ...args: any[]): number;
+export function base58toNumber(str: string, exceptionValue?: bigint, ...args: any[]): bigint;
 /**
  * Convert a base58 encoded string to an Uint8Array (bytes)
  * - A base58 encoded string actually represents a (potentially very big)

package/dist/util/bases/base58.js

@@ -114,15 +114,15 @@ export function isBase58( str )
  *
  * @param {string} str - String to decode
  *
- * @param {number} [exceptionValue]
+ * @param {bigint} [exceptionValue]
  *   If specified, the exceptionValue will be returned instead of
  *   throwing an exception
  *
- * @returns {number} decoded decimal numerical representation
+ * @returns {bigint} decoded decimal numerical representation
  */
 export function base58toNumber( str, exceptionValue )
 {
-  expect.string( str, 'Missing or invalid parameter [str]' );
+  expect.string( 'Missing or invalid parameter [str]' );
 
   let num = BigInt(0);
 

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

@@ -60,9 +60,8 @@ export function compareUsingPath(compareFn: Function, a: any, b: any, path: stri
  * Comparator that can be used for sorting using an object key
  *
  * @param {function} compareFn - Function to use to compare the values
- * @param {string|string[]} path - Object path
- *
- * @param {any} x - First value
- * @param {any} y - Second value
+ * @param {string} key - Object key or path
+ * @param {any} a - First value
+ * @param {any} b - Second value
  */
-export function compareUsingKey(compareFn: Function, key: any, a: any, b: any): any;
+export function compareUsingKey(compareFn: Function, key: string, a: any, b: any): any;

package/dist/util/compare/index.js

@@ -235,10 +235,9 @@ export function compareUsingPath(compareFn, a, b, path) {
  * Comparator that can be used for sorting using an object key
  *
  * @param {function} compareFn - Function to use to compare the values
- * @param {string|string[]} path - Object path
- *
- * @param {any} x - First value
- * @param {any} y - Second value
+ * @param {string} key - Object key or path
+ * @param {any} a - First value
+ * @param {any} b - Second value
  */
 export function compareUsingKey(compareFn, key, a, b) {
 	// @note assume a and b are objects

package/dist/util/exceptions/index.js

@@ -1,5 +1,5 @@
 
-import { DetailedError } from "../../errors/generic.js";
+import { DetailedError } from "../../generic/errors.js";
 
 /**
  * Creates a new Error from the error message and throws it with a reference

package/dist/util/expect/arrays.d.ts

@@ -1,30 +1,30 @@
+/**
+ * Throws a validation error if value is not an array
+ *
+ * @param {any} value
+ */
+export function expect_array(value: any): void;
 /**
  * Throws a validation error if value is not an array of strings
  *
  * @param {any} value
  */
-export function stringArray(value: any): void;
+export function expect_stringArray(value: any): void;
 /**
  * Throws a validation error if value is not an array of objects
  *
  * @param {any} value
  */
-export function objectArray(value: any): void;
+export function expect_objectArray(value: any): void;
 /**
  * Throws an exception if the value is not an Array or the array is empty
  */
-export function notEmptyArray(value: any): void;
+export function expect_notEmptyArray(value: any): void;
 /**
  * Throws a validation error if value is not array like
  * - Checks if the value is an object and has a property `length`
  *
  * @param {any} value
  */
-export function arrayLike(value: any): void;
-export { array_ as array };
-/**
- * Throws a validation error if value is not an array
- *
- * @param {any} value
- */
-declare function array_(value: any): void;
+export function expect_arrayLike(value: any): void;
+export { expect_array as array, expect_stringArray as stringArray, expect_objectArray as objectArray, expect_notEmptyArray as notEmptyArray, expect_arrayLike as arrayLike };

package/dist/util/expect/arrays.js

@@ -5,43 +5,51 @@ import * as v from 'valibot';
  *
  * @param {any} value
  */
-function array_(value) {
+export function expect_array(value) {
 	v.parse(v.instance(Array), value);
 }
 
-export { array_ as array };
+export { expect_array as array };
 
 /**
  * Throws a validation error if value is not an array of strings
  *
  * @param {any} value
  */
-export function stringArray(value) {
+export function expect_stringArray(value) {
 	v.parse(v.array(v.string()), value);
 }
 
+export { expect_stringArray as stringArray };
+
 /**
  * Throws a validation error if value is not an array of objects
  *
  * @param {any} value
  */
-export function objectArray(value) {
+export function expect_objectArray(value) {
 	v.parse(v.array(v.looseObject({})), value);
 }
 
+export { expect_objectArray as objectArray };
+
 /**
  * Throws an exception if the value is not an Array or the array is empty
  */
-export function notEmptyArray(value) {
+export function expect_notEmptyArray(value) {
 	v.parse(v.pipe(v.instance(Array), v.nonEmpty()), value);
 }
 
+export { expect_notEmptyArray as notEmptyArray };
+
 /**
  * Throws a validation error if value is not array like
  * - Checks if the value is an object and has a property `length`
  *
  * @param {any} value
  */
-export function arrayLike(value) {
+export function expect_arrayLike(value) {
 	v.parse(v.object({ length: v.number() }), value);
 }
+
+export { expect_arrayLike as arrayLike };

package/dist/util/expect/index.js

@@ -181,7 +181,7 @@ export function iterable(value) {
 export function store(value) {
 	v.parse(
 		v.custom((value) => {
-			if (!is.object(value) || typeof value.subscribe !== 'function') {
+			if (!is.object(value) || typeof value?.subscribe !== 'function') {
 				return false;
 			}
 
@@ -240,7 +240,7 @@ export function objectNoFunction(value) {
  * @param {any} value
  */
 export function objectOrNull(value) {
-	v.parse(v.union([v.value(null), v.looseObject({})]), value);
+	v.parse(v.union([v.literal(null), v.looseObject({})]), value);
 }
 
 // objectOrUndefined

package/dist/util/expect/primitives.d.ts

@@ -3,28 +3,29 @@
  *
  * @param {any} value
  */
-export function string(value: any): void;
+export function expect_string(value: any): void;
 /**
  * Throws a validation error if value is not a boolean
  *
  * @param {any} value
  */
-export function boolean(value: any): void;
+export function expect_boolean(value: any): void;
 /**
  * Throws a validation error if value is not a number
  *
  * @param {any} value
  */
-export function number(value: any): void;
+export function expect_number(value: any): void;
 /**
  * Throws a validation error if value is not a Symbol
  *
  * @param {any} value
  */
-export function symbol(value: any): void;
+export function expect_symbol(value: any): void;
 /**
  * Throws a validation error if value is not defined
  *
  * @param {any} value
  */
-export function defined(value: any): void;
+export function expect_defined(value: any): void;
+export { expect_string as string, expect_boolean as boolean, expect_number as number, expect_symbol as symbol, expect_defined as defined };

package/dist/util/expect/primitives.js

@@ -5,43 +5,51 @@ import * as v from 'valibot';
  *
  * @param {any} value
  */
-export function string(value) {
+export function expect_string(value) {
 	v.parse(v.string(), value);
 }
 
+export { expect_string as string };
+
 /**
  * Throws a validation error if value is not a boolean
  *
  * @param {any} value
  */
-export function boolean(value) {
+export function expect_boolean(value) {
 	v.parse(v.boolean(), value);
 }
 
+export { expect_boolean as boolean };
+
 /**
  * Throws a validation error if value is not a number
  *
  * @param {any} value
  */
-export function number(value) {
+export function expect_number(value) {
 	v.parse(v.number(), value);
 }
 
+export { expect_number as number };
+
 /**
  * Throws a validation error if value is not a Symbol
  *
  * @param {any} value
  */
-export function symbol(value) {
+export function expect_symbol(value) {
 	v.parse(v.symbol(), value);
 }
 
+export { expect_symbol as symbol };
+
 /**
  * Throws a validation error if value is not defined
  *
  * @param {any} value
  */
-export function defined(value) {
+export function expect_defined(value) {
 	v.parse(
 		v.custom((value) => {
 			if (value === undefined) {
@@ -53,3 +61,5 @@ export function defined(value) {
 		value
 	);
 }
+
+export { expect_defined as defined };

package/dist/util/expect/url.d.ts

@@ -3,30 +3,31 @@
  *
  * @param {any} value
  */
-export function url(value: any): void;
+export function expect_url(value: any): void;
 /**
  * Throws a parse error if value is not a URL or
  * an empty string
  *
  * @param {any} value
  */
-export function urlOrEmptyString(value: any): void;
+export function expect_urlOrEmptyString(value: any): void;
 /**
  * Throws a parse error if value is not a URL path
  *
  * @param {any} value
  */
-export function urlPath(value: any): void;
+export function expect_urlPath(value: any): void;
 /**
  * Throws a parse error if value is not a relative URL
  *
  * @param {any} value
  */
-export function relativeUrl(value: any): void;
+export function expect_relativeUrl(value: any): void;
 /**
  * Throws a parse error if value is not an absolute
  * or relative URL
  *
  * @param {any} value
  */
-export function absOrRelUrl(value: any): void;
+export function expect_absOrRelUrl(value: any): void;
+export { expect_url as url, expect_urlOrEmptyString as urlOrEmptyString, expect_urlPath as urlPath, expect_relativeUrl as relativeUrl, expect_absOrRelUrl as absOrRelUrl };

package/dist/util/expect/url.js

@@ -17,44 +17,54 @@ import {
  *
  * @param {any} value
  */
-export function url(value) {
+export function expect_url(value) {
 	v.parse(HumanUrl, value);
 }
 
+export { expect_url as url };
+
 /**
  * Throws a parse error if value is not a URL or
  * an empty string
  *
  * @param {any} value
  */
-export function urlOrEmptyString(value) {
+export function expect_urlOrEmptyString(value) {
 	v.parse(UrlOrEmptyString, value);
 }
 
+export { expect_urlOrEmptyString as urlOrEmptyString };
+
 /**
  * Throws a parse error if value is not a URL path
  *
  * @param {any} value
  */
-export function urlPath(value) {
+export function expect_urlPath(value) {
 	v.parse(UrlPath, value);
 }
 
+export { expect_urlPath as urlPath };
+
 /**
  * Throws a parse error if value is not a relative URL
  *
  * @param {any} value
  */
-export function relativeUrl(value) {
+export function expect_relativeUrl(value) {
 	v.parse(RelativeUrl, value);
 }
 
+export { expect_relativeUrl as relativeUrl };
+
 /**
  * Throws a parse error if value is not an absolute
  * or relative URL
  *
  * @param {any} value
  */
-export function absOrRelUrl(value) {
+export function expect_absOrRelUrl(value) {
 	v.parse(AbsOrRelUrl, value);
 }
+
+export { expect_absOrRelUrl as absOrRelUrl };

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

@@ -18,17 +18,4 @@ export function once(callback: Function): Function;
  */
 export function debounce(fn: Function, intervalMs?: number): Function;
 export function noop(): void;
-/**
- * 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: any;
+export function defer(fn: any): void;

package/dist/util/index.d.ts

@@ -3,3 +3,8 @@ 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";
+/** @type {typeof originalValibot & { _parse: any }} */
+export const v: typeof originalValibot & {
+    _parse: any;
+};
+import * as originalValibot from 'valibot';

package/dist/util/index.js

@@ -1,5 +1,18 @@
 export { rethrow } from './exceptions/index.js';
 
+import * as originalValibot from 'valibot';
+
+// Create a modified version of valibot with wrapped parse methods
+
+/** @type {typeof originalValibot & { _parse: any }} */
+const v = { ...originalValibot, _parse: originalValibot.parse };
+
+// Replace with wrappers for better stack trace detection
+v.parse = function valibotParseWrapper(schema, input, config) {
+  return this._parse(schema, input, config);
+};
+
+export { v };
 export * as expect from './expect/index.js';
 export * as is from './is/index.js';
 export * as object from './object/index.js';

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

@@ -55,9 +55,10 @@ export function iterable(value: any): boolean;
  *
  * @param {any} value
  *
- * @returns {boolean} true if the value is an Object, but not a Promise
+ * @returns {value is object}
+ *   True if the value is an Object, but not a Promise
  */
-export function object(value: any): boolean;
+export function object(value: any): value is object;
 export { argumentsCheck as arguments };
 /**
  * Check if a value is an Arguments object

package/dist/util/is/index.js

@@ -129,7 +129,8 @@ export function iterable(value) {
  *
  * @param {any} value
  *
- * @returns {boolean} true if the value is an Object, but not a Promise
+ * @returns {value is object}
+ *   True if the value is an Object, but not a Promise
  */
 export function object(value) {
 	if (!(value instanceof Object)) {

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

@@ -1,5 +1,5 @@
 /**
- * @typedef {import('../../classes/data/typedef.js').IterableTreeOptions} IterableTreeOptions
+ * @typedef {import('../../generic/typedef.js').IterableTreeOptions} IterableTreeOptions
  */
 /**
  * Filter all iterated elements
@@ -45,7 +45,7 @@ export function map(iterable: Iterable<any>, transformFn: Function): Generator;
  * @param {boolean} [options.depthFirst=true]
  *   If true, use depth-first traversal, otherwise breadth-first
  *
- * @return {Iterator} iterator object
+ * @return {Iterable<[string[], any]>} iterable that yields [path, value] pairs
  */
 export function iterateObjectEntries(obj: object, options?: {
     walkArrays?: boolean;
@@ -53,19 +53,17 @@ export function iterateObjectEntries(obj: object, options?: {
     outputIntermediateNodes?: boolean;
     ignoreEmptyObjectLeaves?: boolean;
     depthFirst?: boolean;
-}): Iterator<any, any, any>;
+}): Iterable<[string[], any]>;
 /**
  * Get an Iterator object that can be used to iterate over all paths in
  * the object
  *
  * @param {object} obj - Object to iterate
- * @param {IterableTreeOptions & { depthFirst: boolean}} [options]
+ * @param {import('../../generic/data/classes/typedef.js').IterableTreeOptions} [options]
  *
  * @return {Iterable<string[]>} iterable object that yields path arrays
  */
-export function iterateObjectPaths(obj: object, options?: IterableTreeOptions & {
-    depthFirst: boolean;
-}): Iterable<string[]>;
+export function iterateObjectPaths(obj: object, options?: import("../../generic/data/classes/typedef.js").IterableTreeOptions): Iterable<string[]>;
 /**
  * Get an Iterator object that can be used to iterate over all values in
  * the object (at the leaves of the object tree)
@@ -96,4 +94,4 @@ export function sortObjects({ it, getValueFn, reversed }: {
     getValueFn: Function;
     reversed?: boolean;
 }): Promise<any[]>;
-export type IterableTreeOptions = import("../../classes/data/typedef.js").IterableTreeOptions;
+export type IterableTreeOptions = import("../../generic/typedef.js").IterableTreeOptions;

package/dist/util/iterate/index.js

@@ -3,10 +3,10 @@
 import * as expect from '../expect/index.js';
 import { smallestFirst, largestFirst } from '../compare/index.js';
 
-import IterableTree from '../../classes/data/IterableTree.js';
+import { IterableTree } from '../../generic/data.js';
 
 /**
- * @typedef {import('../../classes/data/typedef.js').IterableTreeOptions} IterableTreeOptions
+ * @typedef {import('../../generic/typedef.js').IterableTreeOptions} IterableTreeOptions
  */
 
 /* ------------------------------------------------------------------ Exports */
@@ -77,7 +77,7 @@ export function* map(iterable, transformFn) {
  * @param {boolean} [options.depthFirst=true]
  *   If true, use depth-first traversal, otherwise breadth-first
  *
- * @return {Iterator} iterator object
+ * @return {Iterable<[string[], any]>} iterable that yields [path, value] pairs
  */
 export function iterateObjectEntries(obj, options = {}) {
 	let objectIterator;
@@ -108,11 +108,11 @@ export function iterateObjectEntries(obj, options = {}) {
  * the object
  *
  * @param {object} obj - Object to iterate
- * @param {IterableTreeOptions & { depthFirst: boolean}} [options]
+ * @param {import('../../generic/data/classes/typedef.js').IterableTreeOptions} [options]
  *
  * @return {Iterable<string[]>} iterable object that yields path arrays
  */
-export function iterateObjectPaths(obj, options) {
+export function iterateObjectPaths(obj, options = {}) {
 	let objectIterator;
 
 	const depthFirst =

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

@@ -93,9 +93,8 @@ export function objectSet(obj: object, path: string | any[], value: any, ...args
  * Removes a value at the specified object path from the object.
  * - All parent objects that remain empty will be removed too (recursively)
  *
- * @param {object} obj - Object to set the value in
+ * @param {object} obj - Object to delete the path from
  * @param {string|Array} path - Dot separated string path or array path
- * @param {any} value - value to set
  */
 export function deletePath(obj: object, path: string | any[]): void;
 /**

package/dist/util/object/index.js

@@ -382,9 +382,8 @@ export function objectSet(obj, path, value) {
  * Removes a value at the specified object path from the object.
  * - All parent objects that remain empty will be removed too (recursively)
  *
- * @param {object} obj - Object to set the value in
+ * @param {object} obj - Object to delete the path from
  * @param {string|Array} path - Dot separated string path or array path
- * @param {any} value - value to set
  */
 export function deletePath(obj, path) {
 	expect.object(obj);
@@ -777,7 +776,7 @@ export function patchObject(obj, changes, options = {}) {
 			throw new Error(`Cannot set value [${path}=undefined]`);
 		}
 
-		if (ignoreAdd && Object._get(obj, path) === undefined) {
+		if (ignoreAdd && objectGet(obj, path) === undefined) {
 			// Ignore add
 			continue;
 		} else if (ignoreUpdate && objectGet(obj, path) !== undefined) {

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

@@ -0,0 +1,16 @@
+/**
+ * SSR context detection and prevention utilities
+ */
+/**
+ * Detect if we're being called during SSR/build evaluation
+ * This helps catch improper usage that causes serialization issues
+ *
+ * @returns {boolean} True if in SSR context
+ */
+export function detectSSRContext(): boolean;
+/**
+ * Throws an error if called during SSR context with helpful guidance
+ *
+ * @throws {Error} When called in SSR context
+ */
+export function expectNoSSRContext(): void;