@tspro/ts-utils-lib 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [1.1.0] - 2025-07-12
+### Added
+- Utils.Obj.isObject
+### Changed
+- Switched bundler from webpack to tsup.
+- Switched license from zlib to MIT.
+
+## [1.0.1] - 2025-06-30
+### Changed
+- Configured babel for ES6.
+
 ## [1.0.0] - 2025-06-25
 ### Added
 - First release.

package/LICENSE

@@ -1,22 +1,25 @@
 
-This project is licensed under the zlib License.
+This project is licensed under the MIT License.
 
 ---
 
-Copyright (c) 2023 Stefan++ Software Studio
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
-   claim that you wrote the original software. If you use this software
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+Copyright (c) 2023 PahkaSoft
+ 
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,347 @@
+declare function isArray<T>(a: T[] | unknown): a is T[];
+declare function toArray<T>(a: T | T[]): Array<T>;
+declare function duplicate<T>(a: T[] | undefined): T[] | undefined;
+declare function removeDuplicates<T>(a: T[]): T[];
+declare function removeDuplicatesCmp<T>(arr: ReadonlyArray<T>, cmp: (t1: T, t2: T) => boolean): T[];
+declare function fillArray<T>(fillValue: T, fillCount: number): T[];
+declare function mapSequenceArray<T>(len: number, fn: (i: number) => T): T[];
+declare function getSequenceArray(len: number): number[];
+declare function mapRangeArray<T>(start: number, end: number, fn: (i: number) => T): T[];
+declare function getRangeArray(start: number, end: number): number[];
+declare function arrayContains<T extends unknown>(arg: T[], item: T): boolean;
+declare function chunckArray<A>(arr: ReadonlyArray<A>, chunckSize: number): A[][];
+
+declare const index$6_arrayContains: typeof arrayContains;
+declare const index$6_chunckArray: typeof chunckArray;
+declare const index$6_duplicate: typeof duplicate;
+declare const index$6_fillArray: typeof fillArray;
+declare const index$6_getRangeArray: typeof getRangeArray;
+declare const index$6_getSequenceArray: typeof getSequenceArray;
+declare const index$6_isArray: typeof isArray;
+declare const index$6_mapRangeArray: typeof mapRangeArray;
+declare const index$6_mapSequenceArray: typeof mapSequenceArray;
+declare const index$6_removeDuplicates: typeof removeDuplicates;
+declare const index$6_removeDuplicatesCmp: typeof removeDuplicatesCmp;
+declare const index$6_toArray: typeof toArray;
+declare namespace index$6 {
+  export { index$6_arrayContains as arrayContains, index$6_chunckArray as chunckArray, index$6_duplicate as duplicate, index$6_fillArray as fillArray, index$6_getRangeArray as getRangeArray, index$6_getSequenceArray as getSequenceArray, index$6_isArray as isArray, index$6_mapRangeArray as mapRangeArray, index$6_mapSequenceArray as mapSequenceArray, index$6_removeDuplicates as removeDuplicates, index$6_removeDuplicatesCmp as removeDuplicatesCmp, index$6_toArray as toArray };
+}
+
+interface CSSProperties {
+    padding?: string | number;
+    paddingLeft?: string | number;
+    paddingRight?: string | number;
+    paddingTop?: string | number;
+    paddingBottom?: string | number;
+    left?: string | number;
+    right?: string | number;
+    top?: string | number;
+    bottom?: string | number;
+    width?: string | number;
+    height?: string | number;
+}
+declare function hasClass(el: HTMLElement, className: string): boolean;
+declare function addClass(el: HTMLElement, className: string): void;
+declare function removeClass(el: HTMLElement, className: string): void;
+declare function setOffset(el: HTMLElement, left: number, top: number, unit?: string): void;
+declare function getOffset(el: HTMLElement): {
+    left: number;
+    top: number;
+};
+declare function getWidth(el: HTMLElement | Window): number;
+declare function setWidth(el: HTMLElement, val: number): void;
+declare function getHeight(el: HTMLElement | Window): number;
+declare function setHeight(el: HTMLElement, val: number): void;
+declare function appendTo(el: HTMLElement | SVGElement, to: HTMLElement | SVGElement): void;
+declare function removeFromParent(el: HTMLElement | SVGElement): void;
+declare function setVisibility(el: HTMLElement | SVGElement, visible: boolean): void;
+declare function setRect(el: HTMLElement, left: number, top: number, width: number, height: number, unit?: string): void;
+declare function getButton(btn: HTMLElement | string): HTMLButtonElement | undefined;
+declare function getCanvas(canvas: HTMLElement | string): HTMLCanvasElement | undefined;
+declare function getPadding(style?: CSSProperties): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+declare function getDimension(style?: CSSProperties): {
+    left: number | undefined;
+    top: number | undefined;
+    width: number | undefined;
+    height: number | undefined;
+};
+declare function styleLayoutChanged(style1?: CSSProperties, style2?: CSSProperties): boolean;
+declare function getCanvasTextWidth(text: string, font: string): number;
+
+type index$5_CSSProperties = CSSProperties;
+declare const index$5_addClass: typeof addClass;
+declare const index$5_appendTo: typeof appendTo;
+declare const index$5_getButton: typeof getButton;
+declare const index$5_getCanvas: typeof getCanvas;
+declare const index$5_getCanvasTextWidth: typeof getCanvasTextWidth;
+declare const index$5_getDimension: typeof getDimension;
+declare const index$5_getHeight: typeof getHeight;
+declare const index$5_getOffset: typeof getOffset;
+declare const index$5_getPadding: typeof getPadding;
+declare const index$5_getWidth: typeof getWidth;
+declare const index$5_hasClass: typeof hasClass;
+declare const index$5_removeClass: typeof removeClass;
+declare const index$5_removeFromParent: typeof removeFromParent;
+declare const index$5_setHeight: typeof setHeight;
+declare const index$5_setOffset: typeof setOffset;
+declare const index$5_setRect: typeof setRect;
+declare const index$5_setVisibility: typeof setVisibility;
+declare const index$5_setWidth: typeof setWidth;
+declare const index$5_styleLayoutChanged: typeof styleLayoutChanged;
+declare namespace index$5 {
+  export { type index$5_CSSProperties as CSSProperties, index$5_addClass as addClass, index$5_appendTo as appendTo, index$5_getButton as getButton, index$5_getCanvas as getCanvas, index$5_getCanvasTextWidth as getCanvasTextWidth, index$5_getDimension as getDimension, index$5_getHeight as getHeight, index$5_getOffset as getOffset, index$5_getPadding as getPadding, index$5_getWidth as getWidth, index$5_hasClass as hasClass, index$5_removeClass as removeClass, index$5_removeFromParent as removeFromParent, index$5_setHeight as setHeight, index$5_setOffset as setOffset, index$5_setRect as setRect, index$5_setVisibility as setVisibility, index$5_setWidth as setWidth, index$5_styleLayoutChanged as styleLayoutChanged };
+}
+
+type EnumObject = {
+    [key: string]: string | number;
+};
+type EnumValue<E extends EnumObject> = E extends {
+    [key: string]: string | infer V;
+} ? V : never;
+declare function getEnumValues<E extends EnumObject>(e: E): Array<EnumValue<E>>;
+
+type index$4_EnumObject = EnumObject;
+type index$4_EnumValue<E extends EnumObject> = EnumValue<E>;
+declare const index$4_getEnumValues: typeof getEnumValues;
+declare namespace index$4 {
+  export { type index$4_EnumObject as EnumObject, type index$4_EnumValue as EnumValue, index$4_getEnumValues as getEnumValues };
+}
+
+declare function getMapKeys<K, V>(map: Map<K, V>): K[];
+
+declare const index$3_getMapKeys: typeof getMapKeys;
+declare namespace index$3 {
+  export { index$3_getMapKeys as getMapKeys };
+}
+
+declare function isInteger(n: unknown): n is number;
+declare function linearToDecibels(linearVolume: number): number;
+declare function mod(m: number, n: number): number;
+/**
+ *  Convert number to roman number.
+ *  https://blog.stevenlevithan.com/archives/javascript-roman-numeral-converter
+ */
+declare function romanize(n: number): string;
+declare function toOrdinalNumber(n: number): string;
+declare function interpolateCoord(startX: number, startY: number, endX: number, endY: number, t: number): {
+    x: number;
+    y: number;
+};
+declare function interpolateY(startX: number, startY: number, endX: number, endY: number, x: number): number;
+declare function clamp(num: number, min: number, max: number): number;
+declare function calcNormal(x1: number, y1: number, x2: number, y2: number): {
+    nx: number;
+    ny: number;
+};
+declare function sum(arr: number[]): number;
+
+declare const index$2_calcNormal: typeof calcNormal;
+declare const index$2_clamp: typeof clamp;
+declare const index$2_interpolateCoord: typeof interpolateCoord;
+declare const index$2_interpolateY: typeof interpolateY;
+declare const index$2_isInteger: typeof isInteger;
+declare const index$2_linearToDecibels: typeof linearToDecibels;
+declare const index$2_mod: typeof mod;
+declare const index$2_romanize: typeof romanize;
+declare const index$2_sum: typeof sum;
+declare const index$2_toOrdinalNumber: typeof toOrdinalNumber;
+declare namespace index$2 {
+  export { index$2_calcNormal as calcNormal, index$2_clamp as clamp, index$2_interpolateCoord as interpolateCoord, index$2_interpolateY as interpolateY, index$2_isInteger as isInteger, index$2_linearToDecibels as linearToDecibels, index$2_mod as mod, index$2_romanize as romanize, index$2_sum as sum, index$2_toOrdinalNumber as toOrdinalNumber };
+}
+
+declare function isObject(value: unknown): value is Record<string, unknown>;
+
+declare const index$1_isObject: typeof isObject;
+declare namespace index$1 {
+  export { index$1_isObject as isObject };
+}
+
+/**
+ * toCharArray("abc") => ["a", "b", "c"].
+ * @param str
+ */
+declare function toCharArray(str: string): string[];
+/**
+ * repeat("abc", 3) => "abcabcabc".
+ * repeat("abc", 0) => "".
+ * @param repeatString
+ * @param repeatCount
+ */
+declare function repeatString(repeatString: string, repeatCount: number): string;
+/**
+ * "abcdefgh":chunkSize = 3 => ["abc", "def", "gh"]
+ * @param str
+ * @param chunkSize
+ */
+declare function chunkString(str: string, chunkSize: number): string[];
+/**
+ * Replaces part of string.
+ * @param str
+ * @param pos
+ * @param removeCount
+ * @param insert
+ */
+declare function replaceAt(str: string, pos: number, removeCount: number, insert: string): string;
+/**
+ * Insert string to another.
+ * @param str
+ * @param pos
+ * @param insertStr
+ */
+declare function insertAt(str: string, pos: number, insertStr: string): string;
+/**
+ * Remove part of string.
+ * @param str
+ * @param pos
+ * @param removeCount
+ */
+declare function removeAt(str: string, pos: number, removeCount: number): string;
+/**
+ * "UndeclaredVariable" => "Undeclared variable"
+ * @param PascalString
+ */
+declare function makeSentenceFromPascal(PascalString: string): string;
+
+declare const index_chunkString: typeof chunkString;
+declare const index_insertAt: typeof insertAt;
+declare const index_makeSentenceFromPascal: typeof makeSentenceFromPascal;
+declare const index_removeAt: typeof removeAt;
+declare const index_repeatString: typeof repeatString;
+declare const index_replaceAt: typeof replaceAt;
+declare const index_toCharArray: typeof toCharArray;
+declare namespace index {
+  export { index_chunkString as chunkString, index_insertAt as insertAt, index_makeSentenceFromPascal as makeSentenceFromPascal, index_removeAt as removeAt, index_repeatString as repeatString, index_replaceAt as replaceAt, index_toCharArray as toCharArray };
+}
+
+declare namespace exportUtils {
+  export { index$6 as Arr, index$5 as Dom, index$4 as Enum, index$3 as Map, index$2 as Math, index$1 as Obj, index as Str };
+}
+
+declare namespace Assert {
+    type ErrorConstructor = new (msg: string) => Error;
+    function setErrorClass(ec?: ErrorConstructor): void;
+    function assert<T>(a: T, userMsg?: string): void;
+    function interrupt(userMsg?: string): never;
+    function int(a: unknown, userMsg?: string): number;
+    function eq<T>(a: T, b: T, userMsg?: string): T;
+    function int_eq(a: unknown, b: unknown, userMsg?: string): number;
+    function int_lt(a: unknown, b: unknown, userMsg?: string): number;
+    function int_lte(a: unknown, b: unknown, userMsg?: string): number;
+    function int_gt(a: unknown, b: unknown, userMsg?: string): number;
+    function int_gte(a: unknown, b: unknown, userMsg?: string): number;
+    function int_between(a: unknown, min: unknown, max: unknown, userMsg?: string): number;
+    function odd(a: unknown, userMsg?: string): number;
+    function even(a: unknown, userMsg?: string): number;
+    function in_group<T>(a: T, group: ReadonlyArray<T>, userMsg?: string): T;
+    function finite(a: unknown, userMsg?: string): number;
+    function array_id<T>(arr: Readonly<T[]>, id: unknown, userMsg?: string): number;
+    function array_elem<T>(arr: Readonly<T[]>, id: number, userMsg?: string): T;
+    function require<T>(arg: T, userMsg?: string): NonNullable<T>;
+}
+
+declare namespace Cookies {
+    function setExpireDays(days: number): void;
+    function isConsentPending(): boolean;
+    function accept(): void;
+    function decline(): void;
+    function save<T extends string | number | boolean>(name: string, value: T): T;
+    function read(name: string, defaultValue: string): string;
+    function readInt(name: string, defaultValue: number): number;
+    function readBool(name: string, defaultValue: boolean): boolean;
+    function erase(name: string): void;
+    function eraseAll(): void;
+}
+
+declare namespace Device {
+    const DPI: number;
+    const PxPerMm: number;
+    const ScrollbarWidth: number;
+    const FontSize: number;
+    const IsTouchDevice: boolean;
+    const IsMobileDevice: boolean;
+    const HostAddress: string;
+    function pxToMm(px: number): number;
+    function mmToPx(mm: number): number;
+    function toPx(input: string | number): number;
+}
+
+declare class Stack<T> {
+    private readonly list;
+    push(e: T): T;
+    pop(): T;
+    top(): T;
+    toArray(): T[];
+    get length(): number;
+    clear(): void;
+}
+
+declare class Vec2 {
+    readonly x: number;
+    readonly y: number;
+    constructor(x?: number, y?: number);
+    length(): number;
+    add(a: Vec2): Vec2;
+    sub(a: Vec2): Vec2;
+    mul(a: number): Vec2;
+    div(a: number): Vec2;
+}
+
+/**
+ * LRUCache class: Least Recently Used cache with a fixed capacity
+ *
+ * Provided by ChatGPT.
+ */
+declare class LRUCache<K extends string, V> {
+    private cache;
+    private next;
+    private prev;
+    private head;
+    private tail;
+    private capacity;
+    private size;
+    private maxKeyLength;
+    constructor(maxSize: number, maxKeyLength?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    private touch;
+    private evict;
+    private removeKey;
+    private addToTail;
+}
+
+/**
+ * A cache-like structure optimized for small-range integer keys, including negatives.
+ *
+ * Internally implemented using two sparse arrays: one for non-negative keys,
+ * and one for negative keys (stored by index `-key - 1`).
+ *
+ * @remarks
+ * - Fast access for small integer keys.
+ * - Not suitable for large or sparse key ranges — memory usage may grow significantly.
+ * - Supports `get`, `set`, `delete`, `has` and `clear`
+ *
+ * @example
+ * ```ts
+ * const cache = new SmallIntCache<string>();
+ * cache.set(-2, 'A');
+ * cache.set(3, 'B');
+ * console.log(cache.get(-2)); // 'A'
+ * ```
+ */
+declare class SmallIntCache<V> {
+    private pos;
+    private neg;
+    constructor();
+    set(key: number, value: V): void;
+    get(key: number): V | undefined;
+    has(key: number): boolean;
+    delete(key: number): void;
+    clear(): void;
+}
+
+export { Assert, Cookies, Device, LRUCache, SmallIntCache, Stack, exportUtils as Utils, Vec2 };