@unicom-cloud/utils 0.1.23 → 0.1.24

package/types/dom-helpers/removeEventListener.d.ts

@@ -0,0 +1,11 @@
+import { TaggedEventHandler } from './addEventListener';
+/**
+ * A `removeEventListener` ponyfill
+ *
+ * @param node the element
+ * @param eventName the event name
+ * @param handle the handler
+ * @param options event options
+ */
+declare function removeEventListener<K extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: K, handler: TaggedEventHandler<K>, options?: boolean | EventListenerOptions): void;
+export default removeEventListener;

package/types/dom-helpers/scrollLeft.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets or sets the scroll left position of a given element.
+ *
+ * @param node the element
+ * @param val the position to set
+ */
+declare const _default: (node: Element, val?: number) => number | undefined;
+export default _default;

package/types/dom-helpers/scrollParent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the first scrollable parent of an element.
+ *
+ * @param element Starting element
+ * @param firstPossible Stop at the first scrollable parent, even if it's not currently scrollable
+ */
+export default function scrollParent(element: HTMLElement, firstPossible?: boolean): Document | HTMLElement;

package/types/dom-helpers/scrollTo.d.ts

@@ -0,0 +1 @@
+export default function scrollTo(selected: HTMLElement, scrollParent?: HTMLElement): (() => void) | undefined;

package/types/dom-helpers/scrollTop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets or sets the scroll top position of a given element.
+ *
+ * @param node the element
+ * @param val the position to set
+ */
+declare const _default: (node: Element, val?: number) => number | undefined;
+export default _default;

package/types/dom-helpers/scrollbarSize.d.ts

@@ -0,0 +1 @@
+export default function scrollbarSize(recalc?: boolean): number;

package/types/dom-helpers/siblings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Collects all previous and next sibling elements of a given element.
+ *
+ * @param node the element
+ */
+export default function siblings(node: Element | null): Element[];

package/types/dom-helpers/text.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Collects the text content of a given element.
+ *
+ * @param node the element
+ * @param trim whether to remove trailing whitespace chars
+ * @param singleSpaces whether to convert multiple whitespace chars into a single space character
+ */
+export default function text(node: HTMLElement | null, trim?: boolean, singleSpaces?: boolean): string;

package/types/dom-helpers/toggleClass.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Toggles a CSS class on a given element.
+ *
+ * @param element the element
+ * @param className the CSS class name
+ */
+export default function toggleClass(element: Element | SVGElement, className: string): void;

package/types/dom-helpers/transitionEnd.d.ts

@@ -0,0 +1,2 @@
+export type Listener = (this: HTMLElement, ev: TransitionEvent) => any;
+export default function transitionEnd(element: HTMLElement, handler: Listener, duration?: number | null, padding?: number): () => void;

package/types/dom-helpers/triggerEvent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Triggers an event on a given element.
+ *
+ * @param node the element
+ * @param eventName the event name to trigger
+ * @param bubbles whether the event should bubble up
+ * @param cancelable whether the event should be cancelable
+ */
+export default function triggerEvent<K extends keyof HTMLElementEventMap>(node: HTMLElement | null, eventName: K, bubbles?: boolean, cancelable?: boolean): void;

package/types/dom-helpers/types.d.ts

@@ -0,0 +1,4 @@
+import * as CSS from 'csstype';
+export type HyphenProperty = keyof CSS.PropertiesHyphen;
+export type CamelProperty = keyof CSS.Properties;
+export type Property = HyphenProperty | CamelProperty;

package/types/dom-helpers/width.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the width of a given element.
+ *
+ * @param node the element
+ * @param client whether to use `clientWidth` if possible
+ */
+export default function getWidth(node: HTMLElement, client?: boolean): number;

package/types/filesize/benchmarks/basic-performance.d.ts

@@ -0,0 +1 @@
+export {};

package/types/filesize/benchmarks/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/filesize/benchmarks/options-benchmark.d.ts

@@ -0,0 +1 @@
+export {};

package/types/filesize/benchmarks/partial-benchmark.d.ts

@@ -0,0 +1 @@
+export {};

package/types/filesize/benchmarks/stress-test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/filesize/src/constants.d.ts

@@ -15,6 +15,7 @@ export const OBJECT: "object";
 export const STRING: "string";
 export const EXPONENT: "exponent";
 export const ROUND: "round";
+export const E: "e";
 export const EMPTY: "";
 export const PERIOD: ".";
 export const S: "s";
@@ -40,3 +41,7 @@ export namespace STRINGS {
         export { jedec_1 as jedec };
     }
 }
+export const BINARY_POWERS: number[];
+export const DECIMAL_POWERS: number[];
+export const LOG_2_1024: number;
+export const LOG_10_1000: number;

package/types/filesize/src/helpers.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Optimized base configuration lookup
+ * @param {string} standard - Standard type
+ * @param {number} base - Base number
+ * @returns {Object} Configuration object
+ */
+export function getBaseConfiguration(standard: string, base: number): Object;
+/**
+ * Optimized zero value handling
+ * @param {number} precision - Precision value
+ * @param {string} actualStandard - Standard to use
+ * @param {boolean} bits - Whether to use bits
+ * @param {Object} symbols - Custom symbols
+ * @param {boolean} full - Whether to use full form
+ * @param {Array} fullforms - Custom full forms
+ * @param {string} output - Output format
+ * @param {string} spacer - Spacer character
+ * @returns {string|Array|Object|number} Formatted result
+ */
+export function handleZeroValue(precision: number, actualStandard: string, bits: boolean, symbols: Object, full: boolean, fullforms: any[], output: string, spacer: string): string | any[] | Object | number;
+/**
+ * Optimized value calculation with bits handling
+ * @param {number} num - Input number
+ * @param {number} e - Exponent
+ * @param {boolean} isDecimal - Whether to use decimal powers
+ * @param {boolean} bits - Whether to calculate bits
+ * @param {number} ceil - Ceiling value for auto-increment
+ * @returns {Object} Object with val and e properties
+ */
+export function calculateOptimizedValue(num: number, e: number, isDecimal: boolean, bits: boolean, ceil: number): Object;
+/**
+ * Optimized precision handling with scientific notation correction
+ * @param {number} value - Current value
+ * @param {number} precision - Precision to apply
+ * @param {number} e - Current exponent
+ * @param {number} num - Original number
+ * @param {boolean} isDecimal - Whether using decimal base
+ * @param {boolean} bits - Whether calculating bits
+ * @param {number} ceil - Ceiling value
+ * @param {Function} roundingFunc - Rounding function
+ * @param {number} round - Round value
+ * @returns {Object} Object with value and e properties
+ */
+export function applyPrecisionHandling(value: number, precision: number, e: number, num: number, isDecimal: boolean, bits: boolean, ceil: number, roundingFunc: Function, round: number): Object;
+/**
+ * Optimized number formatting with locale, separator, and padding
+ * @param {number|string} value - Value to format
+ * @param {string|boolean} locale - Locale setting
+ * @param {Object} localeOptions - Locale options
+ * @param {string} separator - Custom separator
+ * @param {boolean} pad - Whether to pad
+ * @param {number} round - Round value
+ * @returns {string|number} Formatted value
+ */
+export function applyNumberFormatting(value: number | string, locale: string | boolean, localeOptions: Object, separator: string, pad: boolean, round: number): string | number;

package/types/idb/index.d.ts

@@ -0,0 +1,21 @@
+declare class IDB {
+    constructor(indexedDBName?: string, objectStoreName?: string);
+    static deleteDatabase(name: string): void;
+    deleteObjectStore(name: string): void;
+    private indexedDBName;
+    private objectStoreName;
+    private idbOpenDBRequestPromise;
+    private getObjectStore;
+    add(key: IDBValidKey, value: unknown): Promise<any>;
+    get(query: IDBValidKey | IDBKeyRange): Promise<any>;
+    getAll(query: IDBValidKey | IDBKeyRange | null, count?: number): Promise<any>;
+    getKey(query: IDBValidKey | IDBKeyRange): Promise<any>;
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<any>;
+    getMany(querys: (IDBValidKey | IDBKeyRange)[]): Promise<any>;
+    put(key: IDBValidKey, value: unknown): Promise<any>;
+    putMany(entries: [unknown, string][]): Promise<any>;
+    delete(key: IDBValidKey | IDBKeyRange): Promise<any>;
+    deleteMany(keys: string[]): Promise<any>;
+    clear(): Promise<any>;
+}
+export default IDB;

package/types/index.d.ts

@@ -1 +1 @@
-export { default as version } from "./version";
+export { default as version } from "./version/index.js";

package/types/is/index.d.ts

@@ -1,40 +1,40 @@
-import isArguments from 'lodash/isArguments';
-import isArray from 'lodash/isArray';
-import isArrayBuffer from 'lodash/isArrayBuffer';
-import isArrayLike from 'lodash/isArrayLike';
-import isArrayLikeObject from 'lodash/isArrayLikeObject';
-import isBoolean from 'lodash/isBoolean';
-import isBuffer from 'lodash/isBuffer';
-import isDate from 'lodash/isDate';
-import isElement from 'lodash/isElement';
-import isEmpty from 'lodash/isEmpty';
-import isEqual from 'lodash/isEqual';
-import isEqualWith from 'lodash/isEqualWith';
-import isError from 'lodash/isError';
-import isFinite from 'lodash/isFinite';
-import isFunction from 'lodash/isFunction';
-import isInteger from 'lodash/isInteger';
-import isLength from 'lodash/isLength';
-import isMap from 'lodash/isMap';
-import isMatch from 'lodash/isMatch';
-import isMatchWith from 'lodash/isMatchWith';
-import isNaN from 'lodash/isNaN';
-import isNative from 'lodash/isNative';
-import isNil from 'lodash/isNil';
-import isNull from 'lodash/isNull';
-import isNumber from 'lodash/isNumber';
-import isObject from 'lodash/isObject';
-import isObjectLike from 'lodash/isObjectLike';
-import isPlainObject from 'lodash/isPlainObject';
-import isRegExp from 'lodash/isRegExp';
-import isSafeInteger from 'lodash/isSafeInteger';
-import isSet from 'lodash/isSet';
-import isString from 'lodash/isString';
-import isSymbol from 'lodash/isSymbol';
-import isTypedArray from 'lodash/isTypedArray';
-import isUndefined from 'lodash/isUndefined';
-import isWeakMap from 'lodash/isWeakMap';
-import isWeakSet from 'lodash/isWeakSet';
+import isArguments from 'lodash/isArguments.js';
+import isArray from 'lodash/isArray.js';
+import isArrayBuffer from 'lodash/isArrayBuffer.js';
+import isArrayLike from 'lodash/isArrayLike.js';
+import isArrayLikeObject from 'lodash/isArrayLikeObject.js';
+import isBoolean from 'lodash/isBoolean.js';
+import isBuffer from 'lodash/isBuffer.js';
+import isDate from 'lodash/isDate.js';
+import isElement from 'lodash/isElement.js';
+import isEmpty from 'lodash/isEmpty.js';
+import isEqual from 'lodash/isEqual.js';
+import isEqualWith from 'lodash/isEqualWith.js';
+import isError from 'lodash/isError.js';
+import isFinite from 'lodash/isFinite.js';
+import isFunction from 'lodash/isFunction.js';
+import isInteger from 'lodash/isInteger.js';
+import isLength from 'lodash/isLength.js';
+import isMap from 'lodash/isMap.js';
+import isMatch from 'lodash/isMatch.js';
+import isMatchWith from 'lodash/isMatchWith.js';
+import isNaN from 'lodash/isNaN.js';
+import isNative from 'lodash/isNative.js';
+import isNil from 'lodash/isNil.js';
+import isNull from 'lodash/isNull.js';
+import isNumber from 'lodash/isNumber.js';
+import isObject from 'lodash/isObject.js';
+import isObjectLike from 'lodash/isObjectLike.js';
+import isPlainObject from 'lodash/isPlainObject.js';
+import isRegExp from 'lodash/isRegExp.js';
+import isSafeInteger from 'lodash/isSafeInteger.js';
+import isSet from 'lodash/isSet.js';
+import isString from 'lodash/isString.js';
+import isSymbol from 'lodash/isSymbol.js';
+import isTypedArray from 'lodash/isTypedArray.js';
+import isUndefined from 'lodash/isUndefined.js';
+import isWeakMap from 'lodash/isWeakMap.js';
+import isWeakSet from 'lodash/isWeakSet.js';
 declare function isPromise(p: any): p is Promise<any>;
 declare function isEmptyArray(o: any): boolean;
 declare function isEmptyObject(o: any): boolean;

package/types/lodash/_DataView.d.ts

@@ -0,0 +1,2 @@
+export default DataView;
+declare var DataView: any;

package/types/lodash/_Hash.d.ts

@@ -0,0 +1,29 @@
+export default Hash;
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function Hash(entries?: any[]): void;
+declare class Hash {
+    /**
+     * Creates a hash object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof hashClear;
+    delete: typeof hashDelete;
+    get: typeof hashGet;
+    has: typeof hashHas;
+    set: typeof hashSet;
+}
+import hashClear from './_hashClear.js';
+import hashDelete from './_hashDelete.js';
+import hashGet from './_hashGet.js';
+import hashHas from './_hashHas.js';
+import hashSet from './_hashSet.js';

package/types/lodash/_LazyWrapper.d.ts

@@ -0,0 +1,26 @@
+export default LazyWrapper;
+/**
+ * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+ *
+ * @private
+ * @constructor
+ * @param {*} value The value to wrap.
+ */
+declare function LazyWrapper(value: any): void;
+declare class LazyWrapper {
+    /**
+     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+     *
+     * @private
+     * @constructor
+     * @param {*} value The value to wrap.
+     */
+    private constructor();
+    __wrapped__: any;
+    __actions__: any[];
+    __dir__: number;
+    __filtered__: boolean;
+    __iteratees__: any[];
+    __takeCount__: number;
+    __views__: any[];
+}

package/types/lodash/_ListCache.d.ts

@@ -0,0 +1,29 @@
+export default ListCache;
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function ListCache(entries?: any[]): void;
+declare class ListCache {
+    /**
+     * Creates an list cache object.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof listCacheClear;
+    delete: typeof listCacheDelete;
+    get: typeof listCacheGet;
+    has: typeof listCacheHas;
+    set: typeof listCacheSet;
+}
+import listCacheClear from './_listCacheClear.js';
+import listCacheDelete from './_listCacheDelete.js';
+import listCacheGet from './_listCacheGet.js';
+import listCacheHas from './_listCacheHas.js';
+import listCacheSet from './_listCacheSet.js';

package/types/lodash/_LodashWrapper.d.ts

@@ -0,0 +1,24 @@
+export default LodashWrapper;
+/**
+ * The base constructor for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap.
+ * @param {boolean} [chainAll] Enable explicit method chain sequences.
+ */
+declare function LodashWrapper(value: any, chainAll?: boolean): void;
+declare class LodashWrapper {
+    /**
+     * The base constructor for creating `lodash` wrapper objects.
+     *
+     * @private
+     * @param {*} value The value to wrap.
+     * @param {boolean} [chainAll] Enable explicit method chain sequences.
+     */
+    private constructor();
+    __wrapped__: any;
+    __actions__: any[];
+    __chain__: boolean;
+    __index__: number;
+    __values__: any;
+}

package/types/lodash/_Map.d.ts

@@ -0,0 +1,2 @@
+export default Map;
+declare var Map: any;

package/types/lodash/_MapCache.d.ts

@@ -0,0 +1,29 @@
+export default MapCache;
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function MapCache(entries?: any[]): void;
+declare class MapCache {
+    /**
+     * Creates a map cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    clear: typeof mapCacheClear;
+    delete: typeof mapCacheDelete;
+    get: typeof mapCacheGet;
+    has: typeof mapCacheHas;
+    set: typeof mapCacheSet;
+}
+import mapCacheClear from './_mapCacheClear.js';
+import mapCacheDelete from './_mapCacheDelete.js';
+import mapCacheGet from './_mapCacheGet.js';
+import mapCacheHas from './_mapCacheHas.js';
+import mapCacheSet from './_mapCacheSet.js';

package/types/lodash/_Promise.d.ts

@@ -0,0 +1,2 @@
+export default Promise;
+declare var Promise: any;

package/types/lodash/_Set.d.ts

@@ -0,0 +1,2 @@
+export default Set;
+declare var Set: any;

package/types/lodash/_SetCache.d.ts

@@ -0,0 +1,28 @@
+export default SetCache;
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+declare function SetCache(values?: any[]): void;
+declare class SetCache {
+    /**
+     *
+     * Creates an array cache object to store unique values.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [values] The values to cache.
+     */
+    private constructor();
+    __data__: MapCache;
+    add: typeof setCacheAdd;
+    push: typeof setCacheAdd;
+    has: typeof setCacheHas;
+}
+import MapCache from './_MapCache.js';
+import setCacheAdd from './_setCacheAdd.js';
+import setCacheHas from './_setCacheHas.js';

package/types/lodash/_Stack.d.ts

@@ -0,0 +1,32 @@
+export default Stack;
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+declare function Stack(entries?: any[]): void;
+declare class Stack {
+    /**
+     * Creates a stack cache object to store key-value pairs.
+     *
+     * @private
+     * @constructor
+     * @param {Array} [entries] The key-value pairs to cache.
+     */
+    private constructor();
+    __data__: ListCache;
+    size: any;
+    clear: typeof stackClear;
+    delete: typeof stackDelete;
+    get: typeof stackGet;
+    has: typeof stackHas;
+    set: typeof stackSet;
+}
+import ListCache from './_ListCache.js';
+import stackClear from './_stackClear.js';
+import stackDelete from './_stackDelete.js';
+import stackGet from './_stackGet.js';
+import stackHas from './_stackHas.js';
+import stackSet from './_stackSet.js';

package/types/lodash/_Symbol.d.ts

@@ -0,0 +1,3 @@
+export default Symbol;
+/** Built-in value references. */
+declare var Symbol: any;

package/types/lodash/_Uint8Array.d.ts

@@ -0,0 +1,3 @@
+export default Uint8Array;
+/** Built-in value references. */
+declare var Uint8Array: any;

package/types/lodash/_WeakMap.d.ts

@@ -0,0 +1,2 @@
+export default WeakMap;
+declare var WeakMap: any;

package/types/lodash/_addMapEntry.d.ts

@@ -0,0 +1,10 @@
+export default addMapEntry;
+/**
+ * Adds the key-value `pair` to `map`.
+ *
+ * @private
+ * @param {Object} map The map to modify.
+ * @param {Array} pair The key-value pair to add.
+ * @returns {Object} Returns `map`.
+ */
+declare function addMapEntry(map: Object, pair: any[]): Object;

package/types/lodash/_addSetEntry.d.ts

@@ -0,0 +1,10 @@
+export default addSetEntry;
+/**
+ * Adds `value` to `set`.
+ *
+ * @private
+ * @param {Object} set The set to modify.
+ * @param {*} value The value to add.
+ * @returns {Object} Returns `set`.
+ */
+declare function addSetEntry(set: Object, value: any): Object;

package/types/lodash/_apply.d.ts

@@ -0,0 +1,12 @@
+export default apply;
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+declare function apply(func: Function, thisArg: any, args: any[]): any;

package/types/lodash/_arrayAggregator.d.ts

@@ -0,0 +1,12 @@
+export default arrayAggregator;
+/**
+ * A specialized version of `baseAggregator` for arrays.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+declare function arrayAggregator(array?: any[], setter: Function, iteratee: Function, accumulator: Object): Function;

package/types/lodash/_arrayEach.d.ts

@@ -0,0 +1,11 @@
+export default arrayEach;
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+declare function arrayEach(array?: any[], iteratee: Function): any[];

package/types/lodash/_arrayEachRight.d.ts

@@ -0,0 +1,11 @@
+export default arrayEachRight;
+/**
+ * A specialized version of `_.forEachRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+declare function arrayEachRight(array?: any[], iteratee: Function): any[];

package/types/lodash/_arrayEvery.d.ts

@@ -0,0 +1,12 @@
+export default arrayEvery;
+/**
+ * A specialized version of `_.every` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`.
+ */
+declare function arrayEvery(array?: any[], predicate: Function): boolean;

package/types/lodash/_arrayFilter.d.ts

@@ -0,0 +1,11 @@
+export default arrayFilter;
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+declare function arrayFilter(array?: any[], predicate: Function): any[];