@appartmint/mint 1.2.12 → 1.3.1

package/src/ts/imports/util/async.ts

@@ -1,12 +0,0 @@
-/**
- * Handles asynchronous operations
- */
-export abstract class MintAsync {
-	/**
-	 * Wait n milliseconds
-	 */
-	static wait(ms: number): Promise<void> {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-};
-export default MintAsync;

package/src/ts/imports/util/display.ts

@@ -1,72 +0,0 @@
-/**
- * Imports
- */
-import { EMintSide } from '../enums';
-import { MintSettings } from './settings';
-
-/**
- * Handles the display of elements
- */
-export abstract class MintDisplay {
-	/**
-     * Sets the element's height to its `innerHeight`, then to `auto` after a delay
-     * @param el - the element whose height will be set
-     * @param delay - the amount of time in milliseconds that the show animation will be active
-     * @param from - the side that the element is animating from
-     */
-    static show (el?: HTMLElement | null, delay: number = MintSettings.delay.default, from: EMintSide = EMintSide.Top) : void {
-        if (el) {
-            el.style.display = '';
-            requestAnimationFrame(() => {
-                if (from === EMintSide.Top || from === EMintSide.Bottom) {
-                    el.style.height = `${el.scrollHeight}px`;
-                } else {
-                    el.style.width = `${el.scrollWidth}px`;
-                }
-                
-                setTimeout(() => {
-                    if (from === EMintSide.Top || from === EMintSide.Bottom) {
-                        el.style.height = 'auto';
-                    } else {
-                        el.style.width = 'auto';
-                    }
-                }, delay);
-            });
-        }
-    }
-
-    /**
-     * Sets the element's height to 0
-     * @param el - the element whose height will be set
-     * @param delay - the amount of time in milliseconds that the show animation will be active
-     * @param from - the side that the element is animating from
-     */
-    static hide (el?: HTMLElement | null, delay: number = MintSettings.delay.default, from: EMintSide = EMintSide.Top) : void {
-        if (el) {
-            let height = el.scrollHeight,
-                width = el.scrollWidth,
-                transition = el.style.transition;
-            el.style.transition = '';
-            requestAnimationFrame(() => {
-                if (from === EMintSide.Top || from === EMintSide.Bottom) {
-                    el.style.height = `${height}px`;
-                } else {
-                    el.style.width = `${width}px`;
-                }
-                
-                el.style.transition = transition;
-                requestAnimationFrame(() => {
-                    if (from === EMintSide.Top || from === EMintSide.Bottom) {
-                        el.style.height = '0';
-                    } else {
-                        el.style.width = '0';
-                    }
-                });
-            });
-            setTimeout(() => {
-                el.style.display = 'none';
-            }, delay);
-        }
-    }
-};
-export default MintDisplay;

package/src/ts/imports/util/event.ts

@@ -1,93 +0,0 @@
-import MintSettings from "./settings";
-
-/**
- * Event helper functions
- */
-export abstract class MintEvent {
-	/**
-     * Ensures that a function `func` is run only after not being called for `wait` milliseconds
-     * @param func - the function to debounce
-     * @param wait - the amount of time to wait before running the function
-     * @returns - the debounced function
-     */
-    static debounce (func: Function, wait: number = MintSettings.delay.default) : Function {
-        let timer: number;
-        return function (e: any) {
-            if (timer) {
-                clearTimeout(timer);
-            }
-            timer = setTimeout(func, wait, e);
-        }
-    }
-
-    /**
-     * Ensures that a function `func` is run only after not being called for `wait` milliseconds
-     * @param func - the function to debounce
-     * @param wait - the amount of time to wait before running the function
-     * @returns - the debounced function as an EventListener
-     */
-    static debounceEvent (func: Function, wait: number = MintSettings.delay.default) : EventListener {
-        return MintEvent.debounce(func, wait) as EventListener;
-    }
-
-    /**
-     * Ensures that a function `func` is called at most every `wait` milliseconds with optional leading and trailing calls
-     * @param func - the function to throttle
-     * @param wait - the amount of time between function calls
-     * @param options - leading and trailing options: default = \{ leading: true, trailing, true \}
-     * @returns - the throttled function
-     */
-    static throttle (func: Function,
-                     wait: number = MintSettings.delay.default,
-                     options?: {[key: string]: boolean}) : Function {
-        let context: any, args: any, result: any,
-            timeout: number, previous: number = 0,
-            later: Function = function () {
-                previous = options?.leading === false ? 0 : new Date().getTime();
-                timeout = 0;
-                result = func.apply(context, args);
-                if (!timeout) {
-                    context = args = null;
-                }
-            },
-            throttled: Function = function (this: any): any {
-                let now: number = new Date().getTime();
-                if (!previous && options?.leading === false) {
-                    previous = now;
-                }
-                let remaining: number = wait - now + previous;
-                context = this;
-                args = arguments;
-                if (remaining <= 0 || remaining > wait) {
-                    if (timeout) {
-                        clearTimeout(timeout);
-                        timeout = 0;
-                    }
-                    previous = now;
-                    result = func.apply(context, args);
-                    if (!timeout) {
-                        context = args = null;
-                    }
-                } else if (!timeout && options?.trailing !== false) {
-                    timeout = window.setTimeout(later, remaining);
-                }
-                return result;
-            };
-
-        return throttled;
-    }
-
-    /**
-     * Ensures that a function `func` is called at most every `wait` milliseconds with optional leading and trailing calls
-     * @param func - the function to throttle
-     * @param wait - the amount of time between function calls
-     * @param options - leading and trailing options: default = \{ leading: true, trailing, true \}
-     * @returns - the throttled function as an EventListener
-     */
-    static throttleEvent (func: Function,
-                          wait: number = MintSettings.delay.default,
-                          options?: {[key: string]: boolean}) : EventListener {
-        return MintEvent.throttle(func, wait, options) as EventListener;
-    }
-};
-export default MintEvent;

package/src/ts/imports/util/icon.ts

@@ -1,67 +0,0 @@
-/**
- * Imports
- */
-import mintObject from "./object";
-
-/**
- * Icon helper functions
- */
-export abstract class MintIcon {
-    /**
-     * Default icons
-     */
-    static icons: {[key: string]: string} = {
-        'a[href^="mailto:"]': 'far fa-envelope',
-        'a[href^="tel:"]': 'fas fa-phone-flip',
-        'a[href^="sms:"]': 'far fa-message',
-        'a[href^="https://maps"]': 'fas fa-map-location-dot',
-        'a[href^="http"]': 'fas fa-up-right-from-square'
-    };
-
-    /**
-     * Appends the given icon to the given selector if there is not already an icon appended
-     */
-    static append (icon: string, selector: string): void {
-        let items: NodeListOf<HTMLElement> = document.querySelectorAll(selector);
-        items.forEach((item: HTMLElement) => {
-            let iconElement: HTMLElement = document.createElement('i');
-            iconElement.classList.add(...icon.split(' '));
-            if (!item.querySelector('i')) {
-                item.appendChild(iconElement);
-            }
-			if (iconElement.classList.contains('fa-up-right-from-square')) {
-				item.setAttribute('target', '_blank');
-			}
-        });
-    }
-
-    /**
-     * Updates the icons
-     * @param icons - the icons to update
-     */
-    static update (icons?: {[key: string]: string | false}): void {
-        let activeIcons: {[key: string]: string} = mintObject.removeValues({
-            ...this.icons,
-            ...icons
-        }, [false]);
-
-        Object.keys(activeIcons).forEach((selector: string) => {
-            this.append(activeIcons[selector], selector);
-        });
-    }
-
-    /**
-     * Removes the given icon from the given selector
-     * @param icon - the icon to remove
-     */
-    static remove (icon: string, selector: string): void {
-        let items: NodeListOf<HTMLElement> = document.querySelectorAll(selector);
-        items.forEach((item: HTMLElement) => {
-            let iconElement: HTMLElement | null = item.querySelector('i');
-            if (iconElement) {
-                iconElement.remove();
-            }
-        });
-    }
-};
-export default MintIcon;

package/src/ts/imports/util/index.ts

@@ -1,15 +0,0 @@
-/**
- * Forward all exports from the util directory
- */
-export * from './async';
-export * from './display';
-export * from './event';
-export * from './icon';
-export * from './list';
-export * from './math';
-export * from './object';
-export * from './scroll';
-export * from './selectors';
-export * from './settings';
-export * from './text';
-export * from './window';

package/src/ts/imports/util/list.ts

@@ -1,39 +0,0 @@
-/**
- * List functions for the util library
- */
-export abstract class MintList {
-	/**
-	 * Returns a copy of the provided list with the items in random order
-	 * @param list - the list to shuffle
-	 * @returns - the shuffled list
-	 */
-	static shuffleCopy (list: any[]): any[] {
-		let copy = [...list];
-		for (let i = copy.length - 1; i > 0; i--) {
-			const j = Math.floor(Math.random() * (i + 1));
-			[copy[i], copy[j]] = [copy[j], copy[i]];
-		}
-		return copy;
-	}
-
-	/**
-	 * Filters the array in place based on a test condition and returns the filtered array.
-	 * This method modifies the original array by removing elements that do not pass the test implemented by the provided function.
-	 *
-	 * @template T The type of elements in the array.
-	 * @param {T[]} list The array to filter, which will be modified in place.
-	 * @param {(item: T) => boolean} test A function that tests each element of the array. Return `true` to keep the element, `false` otherwise.
-	 * @returns {T[]} The original array with only the elements that passed the test.
-	 */
-	static filter<T> (list: T[], test: (item: T) => boolean): T[] {
-		let newLength = 0;
-		for (let i = 0; i < list.length; i++) {
-			if (test(list[i])) {
-				list[newLength++] = list[i];
-			}
-		}
-		list.length = newLength;
-		return list;
-	}
-};
-export default MintList;

package/src/ts/imports/util/math.ts

@@ -1,17 +0,0 @@
-/**
- * Math functions for the util library
- */
-export abstract class MintMath {
-    /**
-     * Get a random integer between min and max
-     * @param max Maximum value to return
-     * @param min Minimum value to return (default is 0)
-     * @returns a random integer between min and max
-     */
-    static randomInt (max: number, min: number = 0): number {
-        min = Math.ceil(min);
-        max = Math.floor(max);
-        return Math.floor(Math.random() * (max - min) + min);
-    }
-};
-export default MintMath;

package/src/ts/imports/util/object.ts

@@ -1,234 +0,0 @@
-/**
- * Object functions for the util library
- */
-export abstract class MintObject {
-    /**
-     * Returns true if the provided objects have the same entries
-     */
-     static isSimilar (obj1: any, obj2: any) : boolean {
-        let keys: string[] = Object.keys(obj1);
-        if (keys.length !== Object.keys(obj2).length) {
-            return false;
-        }
-        let isSimilar: boolean = true;
-        keys.forEach((key: string) => {
-            if (obj1[key] !== obj2[key]) {
-                isSimilar = false;
-            }
-        });
-        return isSimilar;
-    }
-
-    /**
-     * Returns true if the first object has at least the same
-     * entries as the second object
-     * @param superset - the object to check
-     * @param subset - the object whose entries are required
-     * @returns - true if the first object is a superset of the second
-     * @recursive
-     */
-    static isSuperset (superset: any, subset: any) : boolean {
-        let isSuperset: boolean = true;
-        
-        // Base case - if the objects are equal, it is a superset
-        if (superset === subset) {
-            return isSuperset;
-        }
-
-        // If the subset isn't an object or array, and doesn't
-        // satisfy the base case, it isn't a superset
-        try {
-            if (Object.keys(subset).length === 0) {
-                return !isSuperset;
-            }
-        }
-        // If the subset is null or undefined, and doesn't satisfy
-        // the base case, it isn't a superset
-        // TODO: Check if other exceptions could occur
-        catch (e) {
-            return !isSuperset;
-        }
-
-        // If the children of the subset are subsets of the
-        // respective children of the superset, it is a superset
-        Object.keys(subset).forEach((key: string) => {
-            isSuperset = isSuperset && MintObject.isSuperset(superset[key], subset[key]);
-        });
-        return isSuperset;
-    }
-
-    /**
-     * Removes object entries by key
-     * @alias mintObject.removeKeys
-     * @param object - the object to remove entries from
-     * @param keys - the keys to remove
-     */
-    static remove (object: any, keys: string[]) : Object {
-        return this.removeKeys(object, keys);
-    }
-
-    /**
-     * Removes object entries by key
-     * @param object - the object to remove entries from
-     * @param keys - the keys to remove
-     */
-    static removeKeys (object: any, keys: string[]) : any {
-        return Object.keys(object).reduce((obj: any, key: string) => {
-            if (!keys.includes(key)) {
-                obj[key] = object[key];
-            }
-            return obj;
-        }, {});
-    }
-
-    /**
-     * Removes object entries by value
-     */
-    static removeValues (object: any, values: any[]) : any {
-        return Object.keys(object).reduce((obj: any, key: string) => {
-            if (!values.includes(object[key])) {
-                obj[key] = object[key];
-            }
-            return obj;
-        }, {});
-    }
-    
-    /**
-     * Sorts an object's entries alphabetically by key
-     */
-    static sort (object: any, compareFn?: (a: string, b: string) => number) : any {
-        return this.sortKeys(object, compareFn);
-    }
-
-    /**
-     * Sorts an object's entries alphabetically by key
-     */
-    static sortKeys (object: any, compareFn?: (a: string, b: string) => number) : any {
-        return Object.keys(object).sort(compareFn).reduce((obj: any, key: string) => {
-            obj[key] = object[key];
-            return obj;
-        }, {});
-    }
-
-    /**
-     * Sorts an object's entries alphabetically by value
-     */
-    static sortValues (object: any, compareFn: (a: any, b: any) => number) : any {
-        return Object.keys(object).sort((a: string, b: string) => compareFn(object[a], object[b])).reduce((obj: any, key: string) => {
-            obj[key] = object[key];
-            return obj;
-        }, {});
-    }
-
-    /**
-     * @alias mintObject.filterKeys
-     */
-    static filter (object: any, keys: string[]) : Object {
-        return this.filterKeys(object, keys);
-    }
-
-    /**
-     * Filters an object by its keys
-     * @param object - the object to filter
-     * @param keys - the keys to keep
-     * @returns - the filtered object
-     */
-    static filterKeys (object: any, keys: string[]) : Object {
-        return keys.reduce((obj: any, key: string) => {
-            obj[key] = object[key];
-            return obj;
-        }, {});
-    }
-
-    /**
-     * Filters an object by its values
-     * @param object - the object to filter
-     * @param values - the values to keep
-     * @returns - the filtered object
-     */
-    static filterValues (object: any, values: any[]) : Object {
-        return Object.keys(object).reduce((obj: any, key: string) => {
-            if (values.includes(object[key])) {
-                obj[key] = object[key];
-            }
-            return obj;
-        }, {});
-    }
-
-    /**
-     * Update two sets of objects
-     * @param original - the original object
-     * @param update - the object to update the original with
-     * @returns - the original objects with updated data from the update
-     */
-    static updateArray (original: any[], update?: any[], key = 'id') : any {
-        
-        // If there are no originals, push the updates
-        if (!update?.length) {
-            update?.forEach((object) => original.push(object));
-        
-        // If there are existing objects
-        } else {
-
-            // Create a dictionary of the updated objects
-            const updateObjects = update.reduce<{ [key: string]: Object }>((objects, object) => ({
-                ...objects,
-                [object?.[key] ?? '']: object
-            }), {});
-
-            // Remove any objects that aren't in the updated objects
-            const missingObjects = original.filter((object) => !updateObjects[object?.[key] ?? '']);
-            missingObjects?.forEach((object) => {
-                const index = original.indexOf(object);
-                if (typeof index == 'number' && index !== -1) {
-                    original.splice(index, 1);
-                }
-            });
-
-            // Update the existing objects with updates
-            original.forEach((object) => {
-                if (updateObjects[object?.[key] ?? '']) {
-                    Object.assign(object, updateObjects[object?.[key] ?? '']);
-                }
-            });
-        }
-
-        // Push any new objects
-        const newObjects = update?.filter((object) => !original.some((existingObject) => existingObject?.[key] === object?.[key]));
-        newObjects?.forEach(newObject => original.push(newObject));
-    }
-
-	/**
-	 * Get an object's key by value
-	 */
-	static getKeyByValue(object: any, value: any): string | undefined {
-		return Object.keys(object).find((key) => object[key] === value);
-	}
-
-	/**
-	 * Create a deep copy of an object
-	 * @recursive
-	 */
-	static deepClone(object: any): any {
-
-		// Clone every property
-		const clone: any = {};
-		for (const key in object) {
-
-			// Functions
-			if (typeof object[key] === 'function') {
-				clone[key] = object[key].bind(clone);
-
-			// Objects
-			} else if (object[key] && typeof object[key] === 'object') {
-				clone[key] = this.deepClone(object[key]);
-			
-			// Primitives
-			} else {
-				clone[key] = object[key];
-			}
-		}
-		return clone;
-	}
-};
-export default MintObject;

package/src/ts/imports/util/scroll.ts

@@ -1,53 +0,0 @@
-/**
- * Imports
- */
-import MintEvent from './event';
-
-/**
- * Scroll functions
- */
-export abstract class MintScroll {
-	/**
-	 * Scroll to the top of the page
-	 */
-	static toTop(): void {
-		window.scrollTo(0, 0);
-	};
-
-	/**
-	 * Scroll to the bottom of the page
-	 */
-	static toBottom(): void {
-		window.scrollTo(0, document.body.scrollHeight);
-	};
-
-	/**
-	 * Show visible elements
-	 */
-	static showElements(): void {
-		requestAnimationFrame(() => {
-			let elements = document.querySelectorAll('.mint-fall-in:not(.mint-show)'),
-				elementsToShow: Element[] = [];
-			for (let i = 0; i < elements.length; i++) {
-				if (elements[i].getBoundingClientRect().top < 0) {
-					elements[i].classList.add('mint-show');
-				} else if (elements[i].getBoundingClientRect().top < window.innerHeight * 3 / 4) {
-					elementsToShow.push(elements[i]);
-				}
-			}
-			for (let i = 0; i < elementsToShow.length; i++) {
-				setTimeout(() => {
-					elementsToShow[i].classList.add('mint-show');
-				}, i * 100);
-			}
-		});
-	}
-
-	/**
-	 * Show visible elements on scroll
-	 */
-	static showElementsOnScroll(): void {
-		window.addEventListener('scroll', MintEvent.throttleEvent(this.showElements, 200));
-	}
-};
-export default MintScroll;