@appartmint/mint 1.2.3 → 1.2.5

package/src/scss/imports/components/_index.scss

@@ -1,16 +1,16 @@
-/// _index.scss - Forward all overrides
-/// @author App Art Mint LLC
-/// 
-/// @group Index
-@charset 'utf-8';
-
-/// Imports
-@use './backgrounds';
-@use './buttons';
-@use './cards';
-@use './embed';
-@use './footer';
-@use './header';
-@use './image';
-@use './recaptcha';
-@use './tables';
+/// _index.scss - Forward all overrides
+/// @author App Art Mint LLC
+/// 
+/// @group Index
+@charset 'utf-8';
+
+/// Imports
+@use './backgrounds';
+@use './buttons';
+@use './cards';
+@use './embed';
+@use './footer';
+@use './header';
+@use './image';
+@use './recaptcha';
+@use './tables';

package/src/scss/imports/global/_grid.scss

@@ -140,5 +140,14 @@
 	#{class(portrait)} {
 		grid-row: span 2;
 	}
+
+	#{class(landscape)} {
+		@include break(sm) {
+			grid-column: span 2;
+		}
+		@include break(lg) {
+			grid-column: span 3;
+		}
+	}
 }
 

package/src/scss/imports/global/_structure.scss

@@ -72,3 +72,12 @@
 #{class(right)} {
 	float: right;
 }
+
+#{class(full-page)} {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+	min-height: calc(100vh - css-var(header-height));
+	min-height: calc(100dvh - css-var(header-height));
+}

package/src/scss/imports/global/_texture.scss

@@ -100,6 +100,7 @@
 	}
 }
 
+/// Alt Texture Styles
 @if $texture-alt-bg and $texture-alt-num {
     @for $num from 1 through $texture-alt-num {
         #{class(texture-#{$num})} {
@@ -110,4 +111,13 @@
             }
         }
     }
-}
+}
+
+/// Overlay texture
+#{class(overlay)} {
+	#{class(border)}, #{class(texture)} {
+		&::before {
+			z-index: 100;
+		}
+	}
+}

package/src/scss/imports/util/_index.scss

@@ -1,9 +1,9 @@
-/// _index.scss - Forward all overrides
-/// @author App Art Mint LLC
-/// 
-/// @group Index
-@charset 'utf-8';
-
-/// Imports
-@forward './util';
-@forward './vars';
+/// _index.scss - Forward all overrides
+/// @author App Art Mint LLC
+/// 
+/// @group Index
+@charset 'utf-8';
+
+/// Imports
+@forward './util';
+@forward './vars';

package/src/ts/imports/enums/side.ts

@@ -1,9 +1,9 @@
-/**
- * Side Enum
- */
-export enum EMintSide {
-    Top,
-    Right,
-    Bottom,
-    Left
-};
+/**
+ * Side Enum
+ */
+export enum EMintSide {
+    Top,
+    Right,
+    Bottom,
+    Left
+};

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

@@ -1,72 +1,72 @@
-/**
- * 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;
+/**
+ * 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 +1,93 @@
-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;
+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/math.ts

@@ -1,17 +1,17 @@
-/**
- * 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;
+/**
+ * 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/window.ts

@@ -1,14 +1,14 @@
-/**
- * Functions related to the browser window.
- */
-export abstract class MintWindow {
-	/**
-     * Returns the width of the window, including fractional pixels
-     * @returns the width of the window
-     */
-    static width () : number {
-        const decimal: number = document.body.getBoundingClientRect().width % 1;
-        return window.innerWidth + decimal;
-    }
-};
-export default MintWindow;
+/**
+ * Functions related to the browser window.
+ */
+export abstract class MintWindow {
+	/**
+     * Returns the width of the window, including fractional pixels
+     * @returns the width of the window
+     */
+    static width () : number {
+        const decimal: number = document.body.getBoundingClientRect().width % 1;
+        return window.innerWidth + decimal;
+    }
+};
+export default MintWindow;