@tylertech/forge-core 2.0.0

package/typings/utils/event-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gets the node path from where the event originated from.
+ * @param evt The event.
+ */
+export declare function getEventPath(evt: Event): HTMLElement[];
+/**
+ * Equivalent to path/composedPath.
+ * Note: Slots and shadow roots are detected, but aren't needed as they are virtually invisible anyway...
+ */
+export declare function composedPath(el: HTMLElement): HTMLElement[];

package/typings/utils/http-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts a JavaScript object to a URI encoded query string.
+ * @param {any} obj The parameters for the query string.
+ */
+export declare function createQueryString(obj: any): string | null;

package/typings/utils/index.d.ts

@@ -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/typings/utils/item-manager.d.ts

@@ -0,0 +1,42 @@
+export declare class ItemManager<T> {
+    private _key?;
+    private _items;
+    constructor(_key?: string[] | undefined);
+    /**
+     * Returns all items.
+     */
+    getItems(): T[];
+    /**
+     * Returns the number of items.
+     */
+    count(): number;
+    /**
+     * Sets the item key.
+     * @param key The item key(s).
+     */
+    setKey(key: string[]): void;
+    /**
+     * Addes the provided items.
+     * @param data The item data.
+     */
+    add(data: T | T[]): this;
+    /**
+     * Removes an item from the selections.
+     * @param data The data to be deselected.
+     */
+    remove(data: T | T[]): this;
+    /**
+     * Removes all selected items.
+     */
+    clear(): this;
+    /**
+     * Determines if the provided item exists in the selections or not.
+     * @param data The data value.
+     */
+    exists(data: T): boolean;
+    /**
+     * Gets the item from the items collection, or null if not found.
+     * @param data The data value.
+     */
+    private _getItem;
+}

package/typings/utils/object-utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 declare function getPropertyValue(obj: any, inPath: string): any;
+/**
+ * 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 declare function findWhere(ary: any[], predicate: any): any;
+/**
+ * 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 declare function findIndexWhere(ary: any[], predicate: any): any;
+/**
+ * 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 declare function createPredicate(key: string[], data: any): any;
+/**
+ * Determines if an object matches a predicate.
+ */
+export declare function matchesPredicate(obj: any, predicate: any): boolean;
+/**
+ * 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 declare function listenOwnProperty(context: any, obj: any, prop: string, listener: (value: any) => void): () => void;

package/typings/utils/platform.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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
+ */
+/**
+ * Class used to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ * @docs-private
+ */
+export declare class Platform {
+    static get isBrowser(): boolean;
+    static get isMobile(): boolean;
+    /** Layout Engines */
+    static get EDGE(): boolean;
+    static get TRIDENT(): boolean;
+    static get BLINK(): boolean;
+    static get WEBKIT(): boolean;
+    /** Browsers and Platform Types */
+    static get IOS(): boolean;
+    static get FIREFOX(): boolean;
+    static get ANDROID(): boolean;
+    SAFARI(): boolean;
+}

package/typings/utils/position-utils.d.ts

@@ -0,0 +1,56 @@
+import { Options as FlipOptions } from '@floating-ui/core/src/middleware/flip';
+import { Options as AutoOptions } from '@floating-ui/core/src/middleware/autoPlacement';
+import { Options as ShiftOptions } from '@floating-ui/core/src/middleware/shift';
+import { Options as HideOptions } from '@floating-ui/core/src/middleware/hide';
+import { Middleware, Placement, Strategy } from '@floating-ui/dom';
+export declare type PositionPlacement = Placement;
+export declare type PositionStrategy = Strategy;
+export interface IElementPosition {
+    x: number;
+    y: number;
+}
+export interface IElementPositionResult extends IElementPosition {
+    visibility: 'visible' | 'hidden';
+}
+export interface IPositionElementConfig {
+    /** The element to apply position to. */
+    element: HTMLElement;
+    /** The target element to position `element` around. */
+    targetElement: HTMLElement;
+    /** The placement position. */
+    placement: PositionPlacement;
+    /** Whether the position values should be applied to the `element` or not. Default is `true`. */
+    apply?: boolean;
+    /** Should the element flip to the opposite placement when not enough room. */
+    flip?: boolean;
+    /** Options to provide to the flip middleware. */
+    flipOptions?: Partial<FlipOptions>;
+    /** Should the element stay visible at the same placement when scrolling. */
+    shift?: boolean;
+    /** Options to provide to the shift middleware. */
+    shiftOptions?: Partial<ShiftOptions>;
+    /** Should the element hide itself when the target element is out of the view. */
+    hide?: boolean;
+    /** Options to provide to the hide middleware. */
+    hideOptions?: Partial<HideOptions>;
+    /** Should the element automatically attempt to locate the best placement, */
+    auto?: boolean;
+    /** Options to provide to the autoPlacement middleware. */
+    autoOptions?: Partial<AutoOptions>;
+    /** Offset positioning to apply to the placement. */
+    offset?: IElementPosition;
+    /** The positioning strategy. */
+    strategy?: PositionStrategy;
+    /** Should positining be applied using a `transform` style. */
+    transform?: boolean;
+    /** The CSS `translate` function to apply to the `transform`. Only applied when `transform` is `true`. */
+    translateFunction?: 'translate3d' | 'translate';
+}
+/** Adjusts the x and y axes by a specified offset amount. */
+export declare const positionOffsetMiddleware: ({ x: offsetX, y: offsetY }: IElementPosition) => Middleware;
+/**
+ * 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 declare function positionElementAsync({ element, targetElement, placement, offset, strategy, apply, flip, flipOptions, auto, autoOptions, shift, shiftOptions, hide, hideOptions, transform, translateFunction }: IPositionElementConfig): Promise<IElementPositionResult>;

package/typings/utils/string-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a string value to dash-case.
+ * Ex. someTestValue => some-test-value
+ * @param {string} value The string to convert
+ */
+export declare function dashify(value: string): string;

package/typings/utils/utils.d.ts

@@ -0,0 +1,104 @@
+/** Generates random characters. Defaults to a length of 5. */
+export declare function randomChars(length?: number): string;
+/**
+ * Checks if an object is undefined or null.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isDefined(obj: any): boolean;
+/**
+ * Checks if an object is a string.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isString(obj: any): obj is string;
+/**
+ * Checks if an object is a boolean.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isBoolean(obj: any): obj is boolean;
+/**
+ * Checks if an object is a number.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isNumber(obj: any): obj is number;
+/** Determines if the provided string value can be parsed into a valid numeric value. */
+export declare function isNumeric(str: string): boolean;
+/**
+ * Checks if an object is a date.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isDate(obj: any): obj is Date;
+/**
+ * Checks if an object is a date and is a valid date.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isValidDate(obj: any): obj is Date;
+/**
+ * Checks if an object is a function.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isFunction(obj: any): boolean;
+/**
+ * Checks if an object is an array.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isArray(obj: any): boolean;
+/**
+ * Checks if an object is an object.
+ * @param {object} obj The object to test.
+ * @returns {boolean}
+ */
+export declare function isObject(obj: any): boolean;
+/**
+ * Coerces a string to a boolean.
+ * @param {string} value The value to convert.
+ * @returns {boolean}
+ */
+export declare function coerceBoolean(value: string): boolean;
+/**
+ * Coerces a string to a number.
+ * @param {string} value The value to convert.
+ * @returns {number}
+ */
+export declare function coerceNumber(value: string): number;
+/** Coerces a string representation of an array of numbers, for example: `"[1,2,3]"`, to an array instance. */
+export declare function coerceNumberArray(strOrNumOrArray: string | Array<string | number>): number[];
+/**
+ * Compares two objects for deep equality.
+ * @param a
+ * @param b
+ */
+export declare function isDeepEqual(a: any, b: any): boolean;
+/**
+ * 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 declare function debounce(func: any, wait: number, immediate?: boolean): () => any;
+/**
+ * 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 declare function throttle(func: any, wait: number, options?: any): () => any;
+/**
+ * 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 declare function nameof(fn: () => any): string;
+export declare function idleWatch(callback: () => void, timespan: number): void;