@appartmint/mint 1.2.11 → 1.3.0

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 * 200 + i * i * 20);
-			}
-		});
-	}
-
-	/**
-	 * Show visible elements on scroll
-	 */
-	static showElementsOnScroll(): void {
-		window.addEventListener('scroll', MintEvent.throttleEvent(this.showElements, 200));
-	}
-};
-export default MintScroll;

package/src/ts/imports/util/selectors.ts

@@ -1,185 +0,0 @@
-/**
- * CSS-selector helpers
- * @public
- */
-export abstract class MintSelectors {
-    /**
-     * The library name that will be added as a prefix
-     */
-    static lib: string = 'mint';
-
-    /**
-     * The prefix built from the library name
-     */
-    static pre: string = `${this.lib}-`;
-
-    /**
-     * CSS-selector for disabled elements
-     */
-    static disabled: string = '[disabled]';
-
-    /**
-     * CSS-selector for elements with an aria-controls attribute
-     */
-    static hasControls: string = '[aria-controls]';
-
-    /**
-     * CSS-selector for elements with an aria-expanded attribute
-     */
-    static hasExpanded: string = '[aria-expanded]';
-
-    /**
-     * CSS-selector for elements with an href attribute
-     */
-    static hasLink: string = '[href]';
-
-    /**
-     * CSS-selector for elements with a routerLink attribute
-     */
-    static hasRouterLink: string = '[routerLink]';
-
-    /**
-     * CSS-selector for elements with an id attribute
-     */
-    static hasId: string = '[id]';
-
-    /**
-     * CSS-selector for elements that aren't tabbable (i.e. tabindex is negative)
-     */
-    static notTabbable: string = '[tabindex^="-"]';
-
-    /**
-     * CSS-selector for elements that are tabbable (i.e. tabindex isn't negative)
-     */
-    static tabbable: string = `[tabindex]${this.neg(this.notTabbable)}`;
-
-    /**
-     * CSS-selector for elements that can receive focus
-     */
-    static focusable: string = `input${this.neg(this.disabled)}${this.neg(this.notTabbable)},
-                                select${this.neg(this.disabled)}${this.neg(this.notTabbable)},
-                                textarea${this.neg(this.disabled)}${this.neg(this.notTabbable)},
-                                button${this.neg(this.disabled)}${this.neg(this.notTabbable)},
-                                object${this.neg(this.disabled)}${this.neg(this.notTabbable)},
-                                a${this.hasLink}, a${this.hasRouterLink},
-                                area${this.hasLink},
-                                ${this.tabbable}`.replace(/\s/g, '');
-
-    /**
-     * CSS-selector for submenu buttons
-     */
-    static subMenuButtons: string = `button${this.hasControls}`;
-
-    /**
-     * CSS-selector for submenus
-     */
-    static subMenu: string = `${this.subMenuButtons} + ul${this.hasId}`;
-
-    /**
-     * Adds the library prefix to the beginning of the provided string
-     * @param base - the string to be prefixed
-     * @returns - the provided string prefixed with the library name
-     */
-    static prefix (base: string) : string {
-        base = base.toLowerCase();
-        return base.startsWith(this.pre) ? base : `${this.pre}${base}`;
-    }
-
-    /**
-     * Adds two dashes to the beginning of the provided string
-     * @param base - the string to be prefixed
-     * @returns - the provided string prefixed with two dashes
-     */
-    static cssPrefix (base: string) : string {
-        return `--${this.prefix(base.replace(/^-+/, ''))}`;
-    }
-
-    /**
-     * Turns the provided string into a CSS variable call
-     * @param base - the name of the CSS variable to call
-     * @returns - the CSS variable call for the provided string
-     */
-    static cssVar (base: string) : string {
-        return `var(${this.cssPrefix(base)})`;
-    }
-
-    /**
-     * Negates the provided CSS selector
-     * @param base - the CSS selector to negate
-     * @returns - the negated CSS selector
-     */
-    static neg (base: string) : string {
-        return `:not(${base})`;
-    }
-
-    /**
-     * Generates a class CSS selector
-     * @param base - the name of the class to generate
-     * @returns - the generated CSS selector
-     */
-    static class (base: string) : string {
-        return `.${this.prefix(base)}`;
-    }
-
-    /**
-     * Generates an id CSS selector
-     * @param base - the name of the id to generate
-     * @returns - the generated CSS selector
-     */
-    static id (base: string) : string {
-        return `#${this.prefix(base)}`;
-    }
-
-    /**
-     * Generates an aria-controls CSS selector
-     * @param id - the id of the controlled element
-     * @returns - the generated CSS selector
-     */
-    static controls (id?: string | null) : string {
-        return id ? `[aria-controls="${this.prefix(id)}"]` : this.hasControls;
-    }
-
-    /**
-     * Generates an aria-expanded CSS selector
-     * @param bool - whether the element is expanded or not
-     * @returns - the generated CSS selector
-     */
-    static expanded (bool?: boolean | null) : string {
-        return typeof bool === 'boolean' ? `[aria-expanded="${bool}"]` : this.hasExpanded;
-    }
-
-    /**
-     * Returns a NodeList of HTMLElements within the given element that are focusable
-     * @param el - the element whose focusable children will be returned
-     * @returns - the elements within the given element that are focusable
-     */
-    static getFocusables (el?: HTMLElement) : HTMLElement[] {
-        let focusables: HTMLElement[];
-        if (el) {
-            focusables = Array.from(el.querySelectorAll<HTMLElement>(this.focusable));
-        } else {
-            focusables = Array.from(document.querySelectorAll<HTMLElement>(this.focusable));
-        }
-        return focusables.filter((el: HTMLElement) => this.isFocusable(el));
-    }
-
-    /**
-     * Returns true if an element is focusable and false if not,
-     * based on styles (i.e. a parent has display: none;)
-     * NOTE: Still need to determine what other styles may make an element un-focusable
-     * @param el - the element
-     * @returns - true if the element is focusable; false if not
-     */
-    static isFocusable (el: HTMLElement) : boolean {
-        let current: HTMLElement | null = el;
-
-        do {
-            if (window.getComputedStyle(current).getPropertyValue('display').toLowerCase() === 'none') {
-                return false;
-            }
-            current = current.parentElement;
-        } while (current);
-        return true;
-    }
-};
-export default MintSelectors;

package/src/ts/imports/util/settings.ts

@@ -1,85 +0,0 @@
-/**
- * Settings management
- * @public
- */
-export abstract class MintSettings {
-    /**
-     * Value added to all delay variables
-     */
-    static delayBase: number = 0;
-
-    /**
-     * Value multiplied by delay variable index
-     */
-    static delayStep: number = 100;
-
-    /**
-     * Delay variables
-     */
-    static delay: {[key: string]: number} = {
-        instant: this.delayBase + this.delayStep * 0,
-        fast: this.delayBase + this.delayStep * 1,
-        medFast: this.delayBase + this.delayStep * 2,
-        default: this.delayBase + this.delayStep * 3,
-        medSlow: this.delayBase + this.delayStep * 4,
-        slow: this.delayBase + this.delayStep * 5
-    };
-
-    /**
-     * Breakpoint variables
-     */
-    static break: {[key: string]: number} = {
-        z: 0,
-        xs: 480,
-        sm: 768,
-        md: 1024,
-        lg: 1200,
-        xl: 1440
-    };
-
-    /**
-     * Update the provided settings variables
-     * @param settings - Object of settings variables to update
-     */
-    static set (settings: {[key: string]: any}) : void {
-        let newDelay: boolean = false;
-        if (typeof settings.delayBase === 'number') {
-            this.delayBase = settings.delayBase;
-            newDelay = true;
-        }
-        if (typeof settings.delayStep === 'number') {
-            this.delayStep = settings.delayStep;
-            newDelay = true;
-        }
-        if (newDelay) {
-            this.setDelay();
-        }
-
-        if (settings.delay && Object.keys(settings.delay).length) {
-            if (Object.values(settings.delay).reduce((prev: any, next: any) => prev && typeof next === 'number', true)) {
-                this.delay = {...this.delay, ...settings.delay};
-            }
-        }
-
-        if (settings.break && Object.keys(settings.break).length) {
-            if (Object.values(settings.break).reduce((prev: any, next: any) => prev && typeof next === 'number', true)) {
-                this.break = {...this.break, ...settings.break};
-            }
-        }
-    }
-
-    /**
-     * Updates the delay variables based on `this.delayBase` and `this.delayStep`
-     */
-    protected static setDelay () : void {
-        this.delay = {
-            instant: this.delayBase + this.delayStep * 0,
-            fast: this.delayBase + this.delayStep * 1,
-            medFast: this.delayBase + this.delayStep * 2,
-            default: this.delayBase + this.delayStep * 3,
-            medSlow: this.delayBase + this.delayStep * 4,
-            slow: this.delayBase + this.delayStep * 5
-        };
-    }
-};
-export default MintSettings;

package/src/ts/imports/util/text.ts

@@ -1,151 +0,0 @@
-/**
- * Functions for analyzing and manipulating text.
- */
-export abstract class MintText {
-
-	/**
-	 * Generate a slug from a string
-	 * @param text - The string to slugify
-	 * @returns The slugified string
-	 */
-	static slug (text?: string): string {
-		return text?.trim()
-			.toLowerCase()
-			.replace(/'/g, '')
-			.replace(/\W+/g, '-')
-			.replace(/-+/g, '-')
-			.replace(/^-+|-+$/g, '')
-			.replace(/^\/+|\/+$/g, '') ?? '';
-	}
-
-	/**
-	 * Generate a title from a slug
-	 * @param slug - The slug to generate a title from
-	 * @returns The title
-	 */
-	static unslug (slug: string): string {
-		return this.titleCase(slug.replace(/[-/]+/g, ' '));
-	}
-
-	/**
-	 * Format a phone number
-	 * @param phone - The phone number to format
-	 * @returns The formatted phone number
-	 */
-	static phone (phone?: string | number): string {
-		const given = phone?.toString().trim() ?? '';
-		if (given === '(' || given === '') {
-			return given;
-		}
-
-		let numbers = given.replace(/\D/g, '') ?? '',
-			formatted = '';
-
-		if (numbers.length > 10) {
-			formatted += `+${numbers.slice(0, numbers.length - 10)} `;
-			numbers = numbers.slice(numbers.length - 10);
-		}
-
-		for (var i = 0; i < numbers.length; i++) {
-			switch (i) {
-				case 0:
-					formatted += '(';
-					break;
-				case 3:
-					formatted += ') ';
-					break;
-				case 6:
-					formatted += '-';
-					break;
-			}
-			formatted += numbers[i];
-		}
-
-		switch (given[given.length - 1]) {
-			case ')':
-				if (i === 3) {
-					formatted += ') ';
-				}
-				break;
-			case '-':
-				if (i === 6) {
-					formatted += '-';
-				}
-				break;
-		}
-
-		return formatted;
-	}
-
-	/**
-	 * Pluralize the given word
-	 */
-	static plural (word: string): string {
-		if (word.endsWith('ies') ||
-			word.endsWith('es') ||
-			(word.endsWith('s') && !word.endsWith('us') && !word.endsWith('is') && !word.endsWith('ss'))) {
-			return word;
-		}
-
-		if (word.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(word.charAt(word.length - 2))) {
-			return word.slice(0, -1) + 'ies';
-		}
-
-		if (word.endsWith('s') || word.endsWith('sh') || word.endsWith('ch') || word.endsWith('x') || word.endsWith('z')) {
-			return word + 'es';
-		}
-
-		return word + 's';
-	}
-
-	/**
-	 * Capitalize the first letter of the given word
-	 */
-	static titleCase (text: string): string {
-		return text
-			.toLowerCase()
-			.replace(/(?:^|\s)\S/g, a => a.toUpperCase());
-	}
-
-	/**
-     * Copies the provided text to the clipboard
-     * @param text - the text to copy
-     * @returns - true if the text was successfully copied to the clipboard; else false
-     */
-    static copyText (text: string) : boolean {
-        let textArea: HTMLTextAreaElement = document.createElement('textarea');
-
-        if (!text || !textArea) {
-            return false;
-        }
-
-        textArea.value = text;
-        textArea.style.cssText = `
-            position: fixed;
-            top: 0;
-            left: 0;
-            transform: translate(-100%, -100%);
-            opacity: 0;
-            z-index: -1;
-        `;
-
-        document.body.appendChild(textArea);
-        textArea.select();
-        textArea.setSelectionRange(0, 99999);
-        navigator.clipboard.writeText(textArea.value);
-        document.body.removeChild(textArea);
-
-        return true;
-    }
-
-    /**
-     * Tests the validity of an email address
-     * @see {@link https://stackoverflow.com/questions/201323/how-can-i-validate-an-email-address-using-a-regular-expression}
-     * @param text - the string to test
-     * @returns - true if the given string is an email address; false if not
-     */
-    static isEmail (text: string) : boolean {
-        return null !== text.match(/(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/);
-    }
-};
-export default MintText;