@tylertech/forge-core 2.0.0

package/esm/utils/event-utils.js

@@ -0,0 +1,30 @@
+/**
+ * Gets the node path from where the event originated from.
+ * @param evt The event.
+ */
+export function getEventPath(evt) {
+    return evt.path || (evt.composedPath && evt.composedPath()) || composedPath(evt.target);
+}
+/**
+ * Equivalent to path/composedPath.
+ * Note: Slots and shadow roots are detected, but aren't needed as they are virtually invisible anyway...
+ */
+export function composedPath(el) {
+    const path = [];
+    while (el) {
+        if (el.shadowRoot) {
+            if (el.shadowRoot.activeElement) {
+                path.push(el.shadowRoot.activeElement);
+            }
+            path.push(el.shadowRoot);
+        }
+        path.push(el);
+        if (el.tagName === 'HTML') {
+            path.push(document);
+            path.push(window);
+            break;
+        }
+        el = el.parentElement;
+    }
+    return path;
+}

package/esm/utils/http-utils.js

@@ -0,0 +1,26 @@
+/**
+ * Converts a JavaScript object to a URI encoded query string.
+ * @param {any} obj The parameters for the query string.
+ */
+export function createQueryString(obj) {
+    if (!obj || obj.length === 0) {
+        return null;
+    }
+    const params = [];
+    for (const property in obj) {
+        if (!obj.hasOwnProperty(property)) {
+            continue;
+        }
+        if (obj[property] instanceof Array) {
+            for (const index in obj[property]) {
+                if (obj[property].hasOwnProperty(index)) {
+                    params.push(encodeURIComponent(property) + '=' + (obj[property][index] !== null && typeof obj[property][index] !== 'undefined' ? encodeURIComponent(obj[property][index]) : ''));
+                }
+            }
+        }
+        else {
+            params.push(encodeURIComponent(property) + '=' + (obj[property] !== null && typeof obj[property] !== 'undefined' ? encodeURIComponent(obj[property]) : ''));
+        }
+    }
+    return '?' + params.join('&');
+}

package/esm/utils/index.js

@@ -0,0 +1,11 @@
+export * from './a11y';
+export * from './clipboard';
+export * from './dom-utils';
+export * from './event-utils';
+export * from './http-utils';
+export * from './item-manager';
+export * from './object-utils';
+export * from './platform';
+export * from './position-utils';
+export * from './string-utils';
+export * from './utils';

package/esm/utils/item-manager.js

@@ -0,0 +1,82 @@
+import { findWhere, createPredicate } from './object-utils';
+export class ItemManager {
+    constructor(_key) {
+        this._key = _key;
+        this._items = [];
+    }
+    /**
+     * Returns all items.
+     */
+    getItems() {
+        return [...this._items];
+    }
+    /**
+     * Returns the number of items.
+     */
+    count() {
+        return this._items.length;
+    }
+    /**
+     * Sets the item key.
+     * @param key The item key(s).
+     */
+    setKey(key) {
+        this._key = key;
+    }
+    /**
+     * Addes the provided items.
+     * @param data The item data.
+     */
+    add(data) {
+        if (!(data instanceof Array)) {
+            data = [data];
+        }
+        data.forEach(item => {
+            if (!this.exists(item)) {
+                this._items.push(item);
+            }
+        });
+        return this;
+    }
+    /**
+     * Removes an item from the selections.
+     * @param data The data to be deselected.
+     */
+    remove(data) {
+        if (!(data instanceof Array)) {
+            data = [data];
+        }
+        for (let i = data.length - 1; i >= 0; i--) {
+            if (this.exists(data[i])) {
+                this._items.splice(this._items.indexOf(this._getItem(data[i])), 1);
+            }
+        }
+        return this;
+    }
+    /**
+     * Removes all selected items.
+     */
+    clear() {
+        this._items = [];
+        return this;
+    }
+    /**
+     * Determines if the provided item exists in the selections or not.
+     * @param data The data value.
+     */
+    exists(data) {
+        return this._getItem(data) !== null;
+    }
+    /**
+     * Gets the item from the items collection, or null if not found.
+     * @param data The data value.
+     */
+    _getItem(data) {
+        if (this._key) {
+            return findWhere(this._items, createPredicate(this._key, data)) || null;
+        }
+        else {
+            return this._items.find(item => item === data) || null;
+        }
+    }
+}

package/esm/utils/object-utils.js

@@ -0,0 +1,101 @@
+/**
+ * This method will find a value in a JavaScript object using a string path.
+ * Example:
+ *   var obj = { one: 1, two: { twoOne: 21, twoTwo: 22, twoThree: [{ threeOne: 31 }] } };
+ *   getPropertyValue(obj, 'two.twoOne'); // 21
+ *   getPropertyValue(obj, 'one'); // 1
+ *   getPropertyValue(obj, 'two.twoThree[0].threeOne'); // 31
+ *
+ * Inspired by "Alnitak"'s answer on stack overflow:
+ * http://stackoverflow.com/questions/6491463/accessing-nested-javascript-objects-with-string-key
+ */
+export function getPropertyValue(obj, inPath) {
+    let path = inPath.replace(/\[(\w+)\]/g, '.$1'); // Convert indexes to properties
+    path = path.replace(/^\./, ''); // Strip a leading dot
+    const ary = path.split('.');
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < ary.length; ++i) {
+        const property = ary[i];
+        if (obj && typeof obj === 'object' && property in obj) {
+            obj = obj[property];
+        }
+        else {
+            obj = '';
+            break;
+        }
+    }
+    return obj;
+}
+/**
+ * A wrapper around Array.prototype.find to allow for passing in a predicate.
+ * @param {any[]} ary The array to search.
+ * @param {any} predicate The predicate.
+ */
+export function findWhere(ary, predicate) {
+    return ary.find(item => matchesPredicate(item, predicate));
+}
+/**
+ * A wrapper around Array.prototype.findIndex to allow for passing in a predicate.
+ * @param {any[]} ary The array to search.
+ * @param {any} predicate The predicate.
+ */
+export function findIndexWhere(ary, predicate) {
+    return ary.findIndex(item => matchesPredicate(item, predicate));
+}
+/**
+ * This function will create a predicate in the form of "{ [property name]: [value] }" where the square brackets are
+ * replaced with the actual property name and value for the data.
+ */
+export function createPredicate(key, data) {
+    if (!key || !key.length) {
+        throw new Error('Invalid key');
+    }
+    const predicate = {};
+    for (const propertyName of key) {
+        if (Object.prototype.hasOwnProperty.call(data, propertyName)) {
+            predicate[propertyName] = data[propertyName];
+        }
+        else {
+            throw new Error(`Invalid key. The property "${propertyName}" does not exist in the data.`);
+        }
+    }
+    return predicate;
+}
+/**
+ * Determines if an object matches a predicate.
+ */
+export function matchesPredicate(obj, predicate) {
+    return Object.keys(predicate).every(key => obj[key] === predicate[key]);
+}
+/**
+ * Decorates an object by overriding its property descriptor to add a listener invocation in its dynamically created setter.
+ * Note: This does retain existing functionality, and will only work with configurable properties.
+ * @param context The `this` context to use for the listener.
+ * @param obj The object to decorate.
+ * @param prop The property to override.
+ * @param listener The listener function that will be executed when the property values changes.
+ * @returns A function that can be invoked to return the property to its original property descriptor.
+ */
+export function listenOwnProperty(context, obj, prop, listener) {
+    let propObj = obj;
+    if (!obj.hasOwnProperty(prop)) {
+        propObj = Object.getPrototypeOf(obj);
+    }
+    const originalValueDescriptor = Object.getOwnPropertyDescriptor(propObj, prop);
+    if (!originalValueDescriptor) {
+        throw new Error(`Property ${prop} does not exist.`);
+    }
+    Object.defineProperty(obj, prop, {
+        configurable: true,
+        get() {
+            return originalValueDescriptor.get ? originalValueDescriptor.get.apply(this, arguments) : undefined;
+        },
+        set() {
+            if (originalValueDescriptor.set) {
+                originalValueDescriptor.set.apply(this, arguments);
+            }
+            listener.apply(context, arguments);
+        }
+    });
+    return () => Object.defineProperty(obj, prop, originalValueDescriptor);
+}

package/esm/utils/platform.js

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+// Whether the current platform supports the V8 Break Iterator. The V8 check
+// is necessary to detect all Blink based browsers.
+const hasV8BreakIterator = typeof Intl !== 'undefined' && Intl.v8BreakIterator;
+/**
+ * Class used to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ * @docs-private
+ */
+export class Platform {
+    static get isBrowser() {
+        return typeof document === 'object' && !!document;
+    }
+    static get isMobile() {
+        return Platform.isBrowser && /Mobi/.test(navigator.userAgent);
+    }
+    /** Layout Engines */
+    static get EDGE() {
+        return Platform.isBrowser && /(edge)/i.test(navigator.userAgent);
+    }
+    static get TRIDENT() {
+        return Platform.isBrowser && /(msie|trident)/i.test(navigator.userAgent);
+    }
+    // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.
+    static get BLINK() {
+        return Platform.isBrowser && (!!(window.chrome || hasV8BreakIterator) && !!CSS && !Platform.EDGE && !Platform.TRIDENT);
+    }
+    // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to
+    // ensure that Webkit runs standalone and is not used as another engine's base.
+    static get WEBKIT() {
+        return Platform.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !Platform.BLINK && !Platform.EDGE && !Platform.TRIDENT;
+    }
+    /** Browsers and Platform Types */
+    static get IOS() {
+        return Platform.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+    }
+    // It's difficult to detect the plain Gecko engine, because most of the browsers identify
+    // them self as Gecko-like browsers and modify the userAgent's according to that.
+    // Since we only cover one explicit Firefox case, we can simply check for Firefox
+    // instead of having an unstable check for Gecko.
+    static get FIREFOX() {
+        return Platform.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
+    }
+    // Trident on mobile adds the android platform to the userAgent to trick detections.
+    static get ANDROID() {
+        return Platform.isBrowser && /android/i.test(navigator.userAgent) && !Platform.TRIDENT;
+    }
+    // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake
+    // this and just place the Safari keyword in the userAgent. To be more safe about Safari every
+    // Safari browser should also use Webkit as its layout engine.
+    SAFARI() {
+        return Platform.isBrowser && /safari/i.test(navigator.userAgent) && Platform.WEBKIT;
+    }
+}

package/esm/utils/position-utils.js

@@ -0,0 +1,59 @@
+import { computePosition, flip as flipMiddleware, hide as hideMiddleware, shift as shiftMiddleware, autoPlacement as autoPlacementMiddleware } from '@floating-ui/dom';
+/** Adjusts the x and y axes by a specified offset amount. */
+export const positionOffsetMiddleware = ({ x: offsetX, y: offsetY }) => ({
+    name: 'positionOffset',
+    fn({ x, y }) {
+        return {
+            x: x + offsetX,
+            y: y + offsetY
+        };
+    }
+});
+/**
+ * Calculates an elements position relative to another element.
+ * @param {IPositionElementConfig} config Configuration to provide when positioning the element.
+ * @returns {IElementPositionResult} The result of the positioning logic.
+ */
+export async function positionElementAsync({ element, targetElement, placement = 'bottom-start', offset, strategy = 'absolute', apply = true, flip = true, flipOptions = {
+    fallbackPlacements: ['top-start', 'top', 'top-end', 'left-start', 'left', 'left-end', 'right-start', 'right', 'right-end'],
+    fallbackStrategy: 'initialPlacement'
+}, auto = false, autoOptions, shift = true, shiftOptions, hide = false, hideOptions, transform = true, translateFunction = 'translate3d' }) {
+    var _a;
+    const middleware = [];
+    // Order of the following middleware is **important**
+    if (offset) {
+        middleware.push(positionOffsetMiddleware(offset));
+    }
+    if (shift) {
+        middleware.push(shiftMiddleware(shiftOptions));
+    }
+    if (flip && !auto) { // flip and auto placement middleware cannot be used together
+        middleware.push(flipMiddleware(flipOptions));
+    }
+    if (auto) {
+        middleware.push(autoPlacementMiddleware(autoOptions));
+    }
+    if (hide) {
+        middleware.push(hideMiddleware(hideOptions));
+    }
+    const { x, y, middlewareData } = await computePosition(targetElement, element, { strategy, placement, middleware });
+    const visibility = ((_a = middlewareData.hide) === null || _a === void 0 ? void 0 : _a.referenceHidden) ? 'hidden' : 'visible';
+    // Should we apply the position information to the element?
+    if (apply) {
+        const styles = {
+            left: transform ? '0' : `${x}px`,
+            top: transform ? '0' : `${y}px`,
+            visibility
+        };
+        if (transform) {
+            if (translateFunction === 'translate') {
+                styles.transform = `translate(${Math.round(x)}px, ${Math.round(y)}px)`;
+            }
+            else {
+                styles.transform = `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;
+            }
+        }
+        Object.assign(element.style, styles);
+    }
+    return { x, y, visibility };
+}

package/esm/utils/string-utils.js

@@ -0,0 +1,12 @@
+import { isDefined, isString } from './utils';
+/**
+ * Converts a string value to dash-case.
+ * Ex. someTestValue => some-test-value
+ * @param {string} value The string to convert
+ */
+export function dashify(value) {
+    if (!isDefined(value) || !isString(value)) {
+        return value;
+    }
+    return value.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}

package/esm/utils/utils.js

@@ -0,0 +1,261 @@
+/** Generates random characters. Defaults to a length of 5. */
+export function randomChars(length = 5) {
+    const skip = 2; // Skip the first two chars which are always "0."
+    return Math.random().toString(36).substring(skip, skip + length);
+}
+/**
+ * Checks if an object is undefined or null.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isDefined(obj) {
+    return typeof obj !== 'undefined' && obj !== null;
+}
+/**
+ * Checks if an object is a string.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isString(obj) {
+    return typeof obj === 'string';
+}
+/**
+ * Checks if an object is a boolean.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isBoolean(obj) {
+    return typeof obj === 'boolean';
+}
+/**
+ * Checks if an object is a number.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isNumber(obj) {
+    return typeof obj === 'number';
+}
+/** Determines if the provided string value can be parsed into a valid numeric value. */
+export function isNumeric(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    return !isNaN(str) && !isNaN(parseFloat(str));
+}
+/**
+ * Checks if an object is a date.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isDate(obj) {
+    return obj instanceof Date;
+}
+/**
+ * Checks if an object is a date and is a valid date.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isValidDate(obj) {
+    if (!isDate(obj)) {
+        return false;
+    }
+    return !isNaN(obj.getTime());
+}
+/**
+ * Checks if an object is a function.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isFunction(obj) {
+    return typeof obj === 'function';
+}
+/**
+ * Checks if an object is an array.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isArray(obj) {
+    return obj instanceof Array;
+}
+/**
+ * Checks if an object is an object.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export function isObject(obj) {
+    return obj instanceof Object;
+}
+/**
+ * Coerces a string to a boolean.
+ * @param {string} value The value to convert.
+ * @returns {boolean}
+ */
+export function coerceBoolean(value) {
+    return value != null && '' + value !== 'false';
+}
+/**
+ * Coerces a string to a number.
+ * @param {string} value The value to convert.
+ * @returns {number}
+ */
+export function coerceNumber(value) {
+    return +value;
+}
+/** Coerces a string representation of an array of numbers, for example: `"[1,2,3]"`, to an array instance. */
+export function coerceNumberArray(strOrNumOrArray) {
+    if (!strOrNumOrArray) {
+        return [];
+    }
+    if (typeof strOrNumOrArray === 'string') {
+        return strOrNumOrArray.replace(/ |\[|]|\"/g, '').split(',').map(n => Number(n));
+    }
+    else if (typeof strOrNumOrArray === 'number') {
+        return [strOrNumOrArray];
+    }
+    else {
+        return strOrNumOrArray.map(n => Number(n));
+    }
+}
+/**
+ * Compares two objects for deep equality.
+ * @param a
+ * @param b
+ */
+export function isDeepEqual(a, b) {
+    return a === b || (typeof a === 'object' && typeof b === 'object' && JSON.stringify(a) === JSON.stringify(b));
+}
+/**
+ * Debounce method.
+ * @param {function} func The function to call.
+ * @param {number} wait The amount of time (milliseconds) to wait.
+ * @param {boolean} [immediate=false] Should the callback be executed once immeadiately.
+ */
+export function debounce(func, wait, immediate = false) {
+    let context;
+    let args;
+    let result;
+    let timeout;
+    let timestamp = 0;
+    const later = () => {
+        const last = Date.now() - timestamp;
+        if (last < wait && last >= 0) {
+            timeout = setTimeout(later, wait - last);
+        }
+        else {
+            timeout = null;
+            if (!immediate) {
+                result = func.apply(context, args);
+                if (!timeout) {
+                    context = args = null;
+                }
+            }
+        }
+    };
+    return function () {
+        context = this;
+        args = arguments;
+        timestamp = Date.now();
+        const callNow = immediate && !timeout;
+        if (!timeout) {
+            timeout = setTimeout(later, wait);
+        }
+        if (callNow) {
+            result = func.apply(context, args);
+            context = args = null;
+        }
+        return result;
+    };
+}
+/**
+ * Throttle method.
+ * @param {function} func The function to call.
+ * @param {number} wait The amount of time (milliseconds) to wait.
+ * @param {object=} options An options object with the following properties
+ *   <ul>
+ *     <li>**leading**: Should the callback be executed once immeadiately.</li>
+ *     <li>**trailing**: Should the callback be executed once after the throttle completes.</li>
+ *   </ul>
+ */
+export function throttle(func, wait, options) {
+    let context;
+    let args;
+    let result;
+    let timeout;
+    let timestamp = 0;
+    options = options || {};
+    const later = () => {
+        timestamp = options.leading === false ? 0 : Date.now();
+        timeout = null;
+        result = func.apply(context, args);
+        if (!timeout) {
+            context = args = null;
+        }
+    };
+    return function () {
+        const now = Date.now();
+        if (!timestamp && options.leading === false) {
+            timestamp = now;
+        }
+        const remaining = wait - (now - timestamp);
+        context = this;
+        args = arguments;
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            timestamp = now;
+            result = func.apply(context, args);
+            if (!timeout) {
+                context = args = null;
+            }
+        }
+        else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(later, remaining);
+        }
+        return result;
+    };
+}
+/**
+ * A minification-safe nameof function for retrieving the name of a property or method at runtime.
+ * Note: this function only works with properties/methods on an object. To get the name of a variable,
+ *       you will need to wrap it within an object.
+ * @param {Function} fn A function the returns a property or method that will be stringified.
+ */
+export function nameof(fn) {
+    const fnString = fn.toString();
+    // fnString should look something like: function () { return _this.canActivate; }
+    // When minified fnString will look something like: function(){return a.canActivate}
+    const nameofRegExp = /[^.]\.([^;}\s]+)(?:[;}\s])/; // Get everything after first dot and before the end of the statement
+    const match = nameofRegExp.exec(fnString);
+    if (!match) {
+        throw new Error(`Could not parse nameof string: ${fnString}`);
+    }
+    return match[1];
+}
+/*
+ * Watches for user events to detect if browser is idle.
+ *
+ * @param callback The function to call when the browser becomes idle.
+ * @param timespan The time to wait before the browser is considered idle.
+ */
+export function idleWatch(callback, timespan) {
+    const events = [
+        'mousedown',
+        'mousemove',
+        'touchstart',
+        'touchmove',
+        'keydown',
+        'wheel',
+        'resize'
+    ];
+    events.forEach(e => {
+        window.addEventListener(e, throttle((event) => {
+            if (timeoutId) {
+                window.clearTimeout(timeoutId);
+            }
+            timeoutId = window.setTimeout(callback, timespan);
+        }, 1000, true), true);
+    });
+    let timeoutId = window.setTimeout(callback, timespan);
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@tylertech/forge-core",
+  "version": "2.0.0",
+  "description": "A library of core web utilities that support Forge Web Component libraries.",
+  "author": "Tyler Technologies, Inc.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tyler-technologies-oss/forge-core.git"
+  },
+  "main": "esm/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "sideEffects": false,
+  "dependencies": {
+    "@floating-ui/dom": "^0.5.0",
+    "tslib": "^2.3.1"
+  }
+}

package/typings/a11y/a11y.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hides an element from the user visually, while keeping it in the DOM.
+ * @param element The element to hide from view.
+ */
+export declare function hideElementVisually(element: HTMLElement): void;

package/typings/a11y/index.d.ts

@@ -0,0 +1 @@
+export * from './a11y';

package/typings/constants/date-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DATE_CONSTANTS: {
+    days: string[];
+    daysLong: string[];
+    months: string[];
+    monthsLong: string[];
+};

package/typings/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './date-constants';