@xh/hoist 57.0.0 → 57.0.1

package/build/types/svc/WebSocketService.d.ts

@@ -0,0 +1,94 @@
+import { HoistService } from '@xh/hoist/core';
+/**
+ * Establishes and maintains a websocket connection to the Hoist server, if enabled via `AppSpec`.
+ *
+ * Once a connection is established, this service exposes a `channelKey` property that is unique to
+ * this user and client app instance. This key can be used in application-specific requests to the
+ * server to identify this unique client app instance / connection. The server can then push
+ * messages as requested - e.g. when a particular query or dataset of interest is updated.
+ *
+ * Callers can register a callback via `subscribe()` to receive incoming messages on a requested
+ * topic. The {@link WebSocketSubscription} returned from `subscribe()` can be used to later
+ * `unsubscribe()` if updates are no longer desired. `HoistModel` and `HoistComponent` callers are
+ * encouraged to save a reference to their subscription via a {@link managed} property to have
+ * callbacks unsubscribed automatically when the component/model is unmounted/destroyed.
+ *
+ * This service also provides a `sendMessage()` method to push messages back to the server over the
+ * same socket, although this is a relatively uncommon usage and is specifically *not* recommended
+ * over plain-old Ajax requests.
+ *
+ * Note this service requires the server-side application to be configured to listen to inbound
+ * websocket connections. See `WebSocketService.groovy` in hoist-core for additional documentation.
+ *
+ * See {@link WebSocketIndicator}, a simple component for displaying connection status.
+ */
+export declare class WebSocketService extends HoistService {
+    static instance: WebSocketService;
+    HEARTBEAT_TOPIC: string;
+    REG_SUCCESS_TOPIC: string;
+    FORCE_APP_SUSPEND_TOPIC: string;
+    /** Unique channel assigned by server upon successful connection. */
+    channelKey: string;
+    /** Last time a message was received, including heartbeat messages. */
+    lastMessageTime: Date;
+    /** Observable flag indicating service is connected and available for use. */
+    get connected(): boolean;
+    /** set to true to log all sent/received messages - very chatty. */
+    logMessages: boolean;
+    private _timer;
+    private _socket;
+    private _subsByTopic;
+    enabled: boolean;
+    constructor();
+    initAsync(): Promise<void>;
+    /**
+     * Subscribe a callback to receive inbound messages for a given topic on a going-forward basis.
+     *
+     * @param topic - application-specific topic of interest.
+     * @param fn - handler to call for each incoming message on the requested topic.
+     * @returns subscription reference that can be used to unsubscribe to future messages for the
+     *      same topic/handler. Callers should take care to save this reference and use it to
+     *      dispose of their subs on destroy.
+     */
+    subscribe(topic: string, fn: (msg: WebSocketMessage) => any): WebSocketSubscription;
+    /**
+     * Cancel a subscription for a given topic/handler.
+     *
+     * @param subscription - WebSocketSubscription returned when the subscription was established.
+     */
+    unsubscribe(subscription: WebSocketSubscription): void;
+    /**
+     * Send a message back to the server via the connected websocket.
+     */
+    sendMessage(message: WebSocketMessage): void;
+    connect(): void;
+    disconnect(): void;
+    heartbeatOrReconnect(): void;
+    shutdown(): void;
+    onOpen(ev: any): void;
+    onClose(ev: any): void;
+    onError(ev: any): void;
+    onMessage(rawMsg: any): void;
+    notifySubscribers(message: any): void;
+    getSubsForTopic(topic: any): WebSocketSubscription[];
+    updateConnectedStatus(): void;
+    installChannelKey(key: any): void;
+    updateLastMessageTime(): void;
+    buildWebSocketUrl(): string;
+    showTestMessageAlert(message: any): void;
+    maybeLogMessage(...args: any[]): void;
+}
+/**
+ * Wrapper class to encapsulate and manage a subscription to messages for a given topic + handler.
+ * Returned from `WebSocketService.subscribe()` and used to `unsubscribe()`.
+ */
+export declare class WebSocketSubscription {
+    topic: string;
+    fn: (msg: WebSocketMessage) => any;
+    constructor(topic: any, fn: any);
+    destroy(): void;
+}
+export interface WebSocketMessage {
+    topic: string;
+    data?: any;
+}

package/build/types/svc/index.d.ts

@@ -0,0 +1,16 @@
+export * from './AlertBannerService';
+export * from './AutoRefreshService';
+export * from './ChangelogService';
+export * from './ConfigService';
+export * from './EnvironmentService';
+export * from './FetchService';
+export * from './GridAutosizeService';
+export * from './GridExportService';
+export * from './IdentityService';
+export * from './IdleService';
+export * from './InspectorService';
+export * from './JsonBlobService';
+export * from './LocalStorageService';
+export * from './PrefService';
+export * from './TrackService';
+export * from './WebSocketService';

package/build/types/utils/async/AsyncUtils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Iterate over an iterable and run a closure on each item - as with `for ... of` - but do so
+ * asynchronously and with minimal waits inserted after a configurable time interval.
+ *
+ * Intended for long-running or compute-intensive loops that would otherwise lock up the browser
+ * if run synchronously. Waiting at regular intervals minimizes blocking of user interactions,
+ * allowing ongoing rendering of UI updates (e.g. load masks) and generally keeping the browser
+ * event loop running.
+ *
+ * Note that if the browser tab is hidden (i.e. document.hidden is true) this loop will be executed
+ * without pauses.  In this case the pauses would be unduly large due to throttling of the event
+ * loop by the browser, and there is no user benefit to avoiding blocking the main thread.
+ *
+ * NOTE this is NOT for use cases where the `fn` arg is itself async - i.e. it does not await the
+ * call to `fn` and is instead for the opposite use case, where fn is *synchronous*. If looking to
+ * run an async operation over a collection, consider a simple and blocking for...of loop.
+ */
+export declare function forEachAsync<T>(collection: Iterable<T>, fn: (val: T, idx: number, collection: Iterable<T>) => void, opts?: {
+    waitAfter?: number;
+    waitFor?: number;
+}): Promise<void>;
+/**
+ * As with `forEachAsync()` above, but in the form of a `while` loop.
+ * @param conditionFn - called before each iteration; return true to continue loop.
+ * @param fn - called without arguments for each iteration.
+ * @param opts - additional options.
+ */
+export declare function whileAsync(conditionFn: () => boolean, fn: () => void, opts?: AsyncLoopOptions): Promise<void>;
+export interface AsyncLoopOptions {
+    /**
+     * Interval in ms after which the loop should pause and wait. If the loop completes before
+     * this interval has passed, no waits will be inserted. Default 50ms.
+     */
+    waitAfter?: number;
+    /**
+     * Wait time in ms for each pause. The default of 0ms should be sufficient to allow an event
+     * loop cycle to run.
+     */
+    waitFor?: number;
+}

package/build/types/utils/async/Timer.d.ts

@@ -0,0 +1,89 @@
+/**
+ *
+ * Promise-aware recurring task timer for use by framework and applications.
+ *
+ * This object is designed to be robust across failing tasks, and never to re-run the task
+ * simultaneously, unless in the case of a timeout.  Callers can optionally specify
+ * the duration of asynchronous tasks by returning a Promise from runFn.
+ *
+ * This object seeks to mirror the API and semantics of the server-side equivalent 'Timer'
+ * as closely as possible. However, there are important differences due to the synchronous
+ * nature of javascript. In particular, there is no support for 'runImmediatelyAndBlock', and the
+ * 'timeout' argument will not be able to interrupt synchronous activity of the runFn.
+ *
+ * All public properties should be considered read-only. See `setInterval()` to change the interval
+ * of this timer dynamically.
+ */
+export declare class Timer {
+    static _timers: Timer[];
+    runFn: () => any;
+    interval: number | (() => number);
+    timeout: number | (() => number);
+    delay: number | boolean;
+    scope: any;
+    intervalUnits: number;
+    timeoutUnits: number;
+    cancelled: boolean;
+    isRunning: boolean;
+    lastRun: Date;
+    /** Create a new Timer. */
+    static create({ runFn, interval, timeout, intervalUnits, timeoutUnits, delay, scope }: TimerSpec): Timer;
+    /**
+     * Permanently cancel *all* running timers.
+     *
+     * This method is intended for framework use only.
+     * It is a one-way operation, intended for permanently halting app activity before sleeping.
+     */
+    static cancelAll(): void;
+    /**
+     * Permanently cancel this timer.
+     */
+    cancel(): void;
+    /**
+     * Change the interval of this timer.
+     *
+     * @param interval - ms to wait between runs or any value `<=0` to pause the timer.
+     */
+    setInterval(interval: number): void;
+    constructor(args: any);
+    private cancelInternal;
+    private heartbeatAsync;
+    private doRunAsync;
+    private internalRunFn;
+    private parseDynamicVal;
+    private parseDelay;
+    private get intervalMs();
+    private get timeoutMs();
+    destroy(): void;
+}
+export interface TimerSpec {
+    /**
+     * Function to run.
+     * For async activity, return a promise to allow timer to prevent overlapping runs.
+     */
+    runFn: () => any;
+    /**
+     * Interval between runs, in milliseconds.
+     * If a number and `<=0` job will not run.
+     * If a function, will be re-evaluated after every timer run.
+     * If a string, will be interpreted as an AppConfig key and looked up to determine the value.
+     */
+    interval: number | (() => number) | string;
+    /**
+     * Timeout for action in milliseconds.
+     * Like interval, this value may also be specified as a function or a config key.
+     * Set to null for no timeout.
+     */
+    timeout?: number | (() => number) | string;
+    /** Units that the interval arg is specified in. Default is ms. */
+    intervalUnits?: number;
+    /** Units that the timeout arg is specified in. Default is ms. */
+    timeoutUnits?: number;
+    /**
+     * Initial delay, in milliseconds.
+     * If specified as true, the value of the delay will be the same as interval.  Default to false.
+     */
+    delay?: number | boolean;
+    /** Scope to run runFn in. */
+    scope?: any;
+}

package/build/types/utils/async/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AsyncUtils';
+export * from './Timer';

package/build/types/utils/datetime/DateTimeUtils.d.ts

@@ -0,0 +1,10 @@
+export declare const MILLISECONDS = 1, SECONDS = 1000, MINUTES: number, HOURS: number, DAYS: number, ONE_SECOND = 1000, ONE_MINUTE: number, ONE_HOUR: number, ONE_DAY: number;
+/**
+ * Is a Date or UTC time stamp older than a certain amount?
+ * Returns true if input time is null.
+ */
+export declare function olderThan(t: Date | number, millis: number): boolean;
+/** Returns midnight browser local time for the provided date, or current date. */
+export declare function startOfDay(date?: Date): Date;
+/** Returns 11:59:59pm browser local time for the provided date, or current date. */
+export declare function endOfDay(date?: Date): Date;

package/build/types/utils/datetime/LocalDate.d.ts

@@ -0,0 +1,94 @@
+import { Moment, MomentInput } from 'moment';
+/**
+ * A Date representation that does not contain time information. Useful for business day or calendar
+ * day data where time and time zone should be explicitly ignored.  Client-side equivalent of the
+ * Java `LocalDate` class.
+ *
+ * This class is immutable. All methods for manipulation return a new LocalDate instance.
+ * For efficiency and to enable strict equality checks, instances of this class are memoized:
+ * only a single version of the object will be created and returned for each calendar day,
+ * as long as the caller uses one of the *public factory methods*, which they always should!
+ *
+ * Unit accepted by manipulation methods are ['year', 'quarter', 'month', 'week', 'day', 'date'].
+ */
+export declare class LocalDate {
+    private static _instances;
+    static VALID_UNITS: string[];
+    private _isoString;
+    private _moment;
+    private _date;
+    /**
+     * Get an instance of this class.
+     * This is the standard way to get an instance of this object from serialized server-side data.
+     *
+     * @param s - a valid date in 'YYYY-MM-DD' or 'YYYYMMDD' format.
+     */
+    static get(s: string): LocalDate;
+    /**
+     * Get an instance of this class.
+     *
+     * Note: Applications should favor using the `get()` factory instead of this method.
+     * `get()` takes an explicit 'YYYYMMDD' or 'YYYY-MM-DD' format and is the safest way to get
+     * a LocalDate.
+     *
+     * @param val - any string, timestamp, or date parsable by moment.js.
+     */
+    static from(val: MomentInput | LocalDate): LocalDate;
+    /** LocalDate representing the current day. */
+    static today(): LocalDate;
+    /** LocalDate representing the current day in the App TimeZone */
+    static currentAppDay(): LocalDate;
+    /** LocalDate representing the current day in the Server TimeZone */
+    static currentServerDay(): LocalDate;
+    /** LocalDate representing the next day. */
+    static tomorrow(): LocalDate;
+    /** LocalDate representing the previous day. */
+    static yesterday(): LocalDate;
+    /** Is the input value a local Date? */
+    static isLocalDate(v: any): boolean;
+    get isoString(): string;
+    get date(): Date;
+    get moment(): Moment;
+    get timestamp(): number;
+    format(...args: any[]): string;
+    dayOfWeek(): string;
+    get isToday(): boolean;
+    get isWeekday(): boolean;
+    get isStartOfMonth(): boolean;
+    get isEndOfMonth(): boolean;
+    get isStartOfQuarter(): boolean;
+    get isEndOfQuarter(): boolean;
+    get isStartOfYear(): boolean;
+    get isEndOfYear(): boolean;
+    toString(): any;
+    toJSON(): any;
+    valueOf(): any;
+    get isLocalDate(): boolean;
+    add(value: any, unit?: string): LocalDate;
+    subtract(value: any, unit?: string): LocalDate;
+    startOf(unit: any): LocalDate;
+    startOfMonth(): LocalDate;
+    startOfQuarter(): LocalDate;
+    startOfYear(): LocalDate;
+    endOf(unit: any): LocalDate;
+    endOfMonth(): LocalDate;
+    endOfQuarter(): LocalDate;
+    endOfYear(): LocalDate;
+    nextDay(): LocalDate;
+    previousDay(): LocalDate;
+    nextWeekday(): LocalDate;
+    previousWeekday(): LocalDate;
+    /** The same date if already a weekday, or the next weekday. */
+    currentOrNextWeekday(): LocalDate;
+    /** The same date if already a weekday, or the previous weekday. */
+    currentOrPreviousWeekday(): LocalDate;
+    diff(other: any, unit?: string): number;
+    /** @internal - use one of the static factory methods instead. */
+    private constructor();
+    private ensureUnitValid;
+}
+/**
+ * Is the input value a local Date?
+ * Convenience alias for LocalDate.isLocalDate()
+ */
+export declare function isLocalDate(val: any): val is LocalDate;

package/build/types/utils/datetime/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DateTimeUtils';
+export * from './LocalDate';

package/build/types/utils/impl/Equals.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function shallowEqualArrays<T = any>(a: T[], b: T[]): boolean;

package/build/types/utils/impl/IsOmitted.d.ts

@@ -0,0 +1,7 @@
+import { Thunkable } from '@xh/hoist/core/types/Types';
+/**
+ * @internal
+ */
+export declare function isOmitted(obj?: {
+    omit?: Thunkable<boolean>;
+}): boolean;

package/build/types/utils/impl/Separators.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `Array.filter()` function to exclude consecutive separators within Blueprint and AgGrid menus.
+ * @internal
+ */
+export declare function filterConsecutiveMenuSeparators(): (it: any, idx: number, arr: any[]) => boolean;
+/**
+ * `Array.filter()` function to exclude consecutive separators within Toolbars.
+ * @internal
+ */
+export declare function filterConsecutiveToolbarSeparators(): (it: any, idx: number, arr: any[]) => boolean;

package/build/types/utils/impl/TimeZone.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal - pending additional support for a client-side Time Zone API.
+ */
+export declare function fmtTimeZone(name: string, offset: number): string;

package/build/types/utils/impl/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Separators';
+export * from './TimeZone';
+export * from './Equals';
+export * from './IsOmitted';

package/build/types/utils/js/BrowserUtils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extract information (if available) about the client browser's window, screen, and network speed.
+ */
+export declare function getClientDeviceInfo(): any;

package/build/types/utils/js/Decorators.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Decorates a class method so that it is debounced by the specified duration.
+ * Based on https://github.com/bvaughn/debounce-decorator.
+ *
+ * @param duration - milliseconds to debounce.
+ */
+export declare function debounced(duration: number): (target: any, key: any, descriptor: any) => any;
+/**
+ * Modify a method or getter so that it will compute once lazily and then cache the results.
+ * Not appropriate for methods that take arguments. Typically useful on immutable objects.
+ */
+export declare function computeOnce(target: any, key: any, descriptor: any): any;
+/**
+ * Modify a method so that its execution is tracked and timed with a debug message.
+ * @see withDebug
+ */
+export declare function logWithDebug(target: any, key: any, descriptor: any): any;
+/**
+ * Modify a member so that it is enumerable. Useful for getters, which default to enumerable = false
+ */
+export declare function enumerable(target: any, key: any, descriptor: any): any;
+/**
+ * Designate a method or getter as abstract so that it throws if it is called directly
+ */
+export declare function abstract(target: any, key: any, descriptor: any): any;

package/build/types/utils/js/DomUtils.d.ts

@@ -0,0 +1,46 @@
+import ResizeObserver from 'resize-observer-polyfill';
+import { SyntheticEvent } from 'react';
+/**
+ * Is this element visible and not within a hidden sub-tree (e.g. hidden tab)?
+ * Based on the underlying css 'display' property of all ancestor properties.
+ */
+export declare function isDisplayed(elem: HTMLElement): boolean;
+/**
+ * Observe when a dom node's size changes.
+ *
+ * @param fn - function to be called with the co-ordinates of the node.
+ * @param node - The DOM node to observe
+ * @param opts - extra options, currently supporting a `debounce` specified in ms.
+ * @returns ResizeObserver used to implement this function. Be sure to call disconnect()
+ *      on this when finished.
+ *
+ * Unlike the raw ResizeObserver implementation, this function will not run the
+ * callback when the dimensions are both changed to 0 or is changed back from 0
+ * to a previous size.  This is to improve performance by avoiding responding to
+ * visibility changes.
+ *
+ * For a hook that conveniently wraps this function see {@link useOnResize}.
+ */
+export declare function observeResize(fn: (size: DOMRect) => any, node: Element, opts?: {
+    debounce?: number;
+}): ResizeObserver;
+/**
+ * Observe when a dom node's visibility changes.
+ *
+ * @param fn - function that takes a single argument with visibility.
+ * @param node - The DOM node to observe
+ * @returns ResizeObserver used to implement this function. Be sure to call disconnect() on this
+ *      when finished.
+ *
+ * For a hook that conveniently wraps this function see {@link useOnVisibleChange}.
+ */
+export declare function observeVisibleChange(fn: (visible: boolean) => any, node: Element): ResizeObserver;
+/**
+ * A convenience handler that will call 'stopPropagation'
+ * and 'preventDefault' on an event.
+ */
+export declare function consumeEvent(e: Event | SyntheticEvent): void;
+/**
+ * A convenience handler that will 'stopPropagation' on an event.
+ */
+export declare function stopPropagation(e: Event | SyntheticEvent): void;

package/build/types/utils/js/HtmlUtils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Strip HTML tags from a source text.
+ */
+export declare function stripTags(value: any): string;

package/build/types/utils/js/LangUtils.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Get a cached value on an object, creating it if it does not yet exist.
+ *
+ * @param obj - object of interest. Must have writable properties.
+ * @param key - key (property name) to cache value at in object.
+ * @param fn - function to generate value if missing.
+ * @returns value stored at key
+ */
+export declare function getOrCreate<V>(obj: any, key: any, fn: () => V): V;
+/**
+ * Return the first defined argument - intended to allow for multiple levels of fallback values or
+ * expressions when evaluating function parameters or configuration object properties.
+ */
+export declare function withDefault<T>(...args: T[]): T;
+export declare function deepFreeze(obj: object): object;
+/**
+ * Output a deep copy of an object or array up to a given depth, beyond which nested contents will
+ * be replaced by a placeholder string.
+ *
+ * @param obj - source object to trim
+ * @param depth - maximum depth within the object tree that will be returned.
+ */
+export declare function trimToDepth(obj: any, depth?: number): any;
+/**
+ * Determine if an object/value can be parsed successfully into JSON.
+ */
+export declare function isJSON(obj: any): boolean;
+/**
+ * Throw an exception if a condition evaluates as truthy.
+ */
+export declare function throwIf(condition: any, message: unknown): void;
+/**
+ * Log a warning to the console if a condition evaluates as truthy.
+ */
+export declare function warnIf(condition: any, message: any): void;
+/**
+ * Log an error to the console if a condition evaluates as truthy.
+ */
+export declare function errorIf(condition: any, message: any): void;
+export interface APIWarnOptions {
+    /**
+     * If provided and undefined, this method will be a no-op.
+     * Useful for testing if a parameter has been provided in caller.
+     */
+    test?: any;
+    /** Version when this API will no longer be supported or this warning should be removed. */
+    v?: string;
+    /** An additional message. Can contain suggestions for alternatives. */
+    msg?: string;
+}
+/**
+ * Document and prevent usage of a removed parameter.
+ */
+export declare function apiRemoved(name: string, opts?: APIWarnOptions): void;
+export declare function apiDeprecated(name: string, opts?: APIWarnOptions): void;
+/**
+ * Throw an exception if the provided object or collection is empty, as per lodash isEmpty().
+ *
+ * @param obj - object or array to test.
+ * @param exceptionMessage - error to throw if empty.
+ */
+export declare function ensureNotEmpty(obj: any, exceptionMessage?: string): void;
+/**
+ * Throw an exception if an array contains any duplicate, non-unique items.
+ *
+ * @param arr - the array to test.
+ * @param exceptionMessage - error to throw if non-unique values found.
+ */
+export declare function ensureUnique(arr: any[], exceptionMessage?: string): void;
+/**
+ * Throw an exception if an array contains any items with non-unique values for the provided key.
+ *
+ * @param arr - the array to test.
+ * @param uniqueKey - the property that must hold a unique value for each item.
+ * @param exceptionMessage - error to throw if non-unique values found.
+ */
+export declare function ensureUniqueBy(arr: any[], uniqueKey: string, exceptionMessage?: string): void;
+/**
+ * Returns the singular version of the plural word passed to it.
+ */
+export declare function singularize(s: string): string;
+/**
+ * Returns the plural version of the singular word passed to it.
+ *
+ * @param s - the string to pluralize.
+ * @param count - if provided, will pluralize to match this number
+ * @param includeCount - include count in the output
+ */
+export declare function pluralize(s: string, count?: number, includeCount?: boolean): string;
+/**
+ * Returns the number with an ordinal suffix (i.e. 1 becomes '1st', 11 becomes '11th').
+ *
+ * @param n - the number to ordinalize
+ */
+export declare function ordinalize(n: number): string;
+/**
+ * Remove when lodash adds Set/Map support.
+ */
+export declare function findIn<T>(collection: Set<T> | Map<unknown, T>, fn: (it: T) => boolean): T;
+/**
+ * A function to be passed to `array.filter()` that excludes consecutive items that match the
+ * provided predicate.  Matches that would ultimately appear at the start or end of the
+ * filtered array are also removed.
+ *
+ * Useful for removing separators that have become extraneous when the items they were separating
+ * have been removed.
+ */
+export declare function filterConsecutive<T>(predicate: (it: T) => boolean): (it: T, idx: number, arr: T[]) => boolean;
+/**
+ * Return value passed or the result of executing it, if it is a function.
+ */
+export declare function executeIfFunction(v: any): any;

package/build/types/utils/js/LogUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Track a function execution with console.log.
+ *
+ * This method will log the provided message(s) with timing information in a single message *after*
+ * the tracked function returns.
+ *
+ * If the function passed to this util returns a Promise, it will wait until the Promise resolves
+ * or completes to finish its logging. The actual object returned by the tracked function will
+ * always be returned directly to the caller.
+ *
+ * @param msgs - message(s) to output after the execution "completes"
+ * @param fn - function to execute
+ * @param source - class, function or string to label the source of the message
+ */
+export declare function withInfo<T>(msgs: string[] | string, fn: () => T, source?: any): T;
+/**
+ * Track a function execution with console.debug.
+ * @see withInfo
+ */
+export declare function withDebug<T>(msgs: string[] | string, fn: () => T, source?: any): T;
+/**
+ * Log a message with console.log.
+ *
+ * @param msgs - message(s) to output
+ * @param source - class, function or string to label the source of the message
+ */
+export declare function logInfo(msgs: string[] | string, source?: any): any;
+/**
+ * Log a message with console.debug.
+ * @see logInfo
+ */
+export declare function logDebug(msgs: string[] | string, source?: any): any;

package/build/types/utils/js/VersionUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Check if a version string falls within a range
+ */
+export declare function checkVersion(version: string, minVersion: string, maxVersion: string): boolean;
+/**
+ * Check if a version string meets a minimum version
+ */
+export declare function checkMinVersion(version: string, minVersion: string): boolean;
+/**
+ * Check if a version string meets a maximum version
+ */
+export declare function checkMaxVersion(version: string, maxVersion: string): boolean;
+/**
+ * Normalizes a Java/Maven style x.0-SNAPSHOT version to a semver compatible x.0.0-SNAPSHOT string.
+ * @returns normalized version, if input matched as above, or input version unmodified.
+ */
+export declare function normalizeVersion(version: string): string;

package/build/types/utils/js/index.d.ts

@@ -0,0 +1,7 @@
+export * from './HtmlUtils';
+export * from './LangUtils';
+export * from './Decorators';
+export * from './LogUtils';
+export * from './DomUtils';
+export * from './BrowserUtils';
+export * from './VersionUtils';

package/build/types/utils/react/ClassName.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generate a string with one or more CSS classes to apply to a component, typically concatenating a
+ * standardized base className with any instance-specific getClassName(s) provided via props and any
+ * optional / conditional class names determined at render-time.
+ *
+ * Components should call this to produce a combined class list and apply it to their outermost
+ * (or otherwise most appropriate) rendered component.
+ *
+ * @param baseName - base class name for the component.
+ * @param props - component props.
+ * @param extraNames - optional, additional class names to append.
+ * @returns concatenated, space-delimited class name appropriate for html className attribute.
+ */
+export declare function getClassName(baseName: string, props: any, ...extraNames: string[]): string;