@rockrms/obsidian-framework 1.16.3-rc.1

package/types/Utility/numberUtils.d.ts

@@ -0,0 +1,54 @@
+declare type NumberFormatOptions = {
+    useGrouping?: boolean;
+};
+/**
+ * Get a formatted string.
+ * Ex: 10001.2 => 10,001.2
+ * @param num
+ */
+export declare function asFormattedString(num: number | null, digits?: number, options?: NumberFormatOptions): string;
+/**
+ * Get a number value from a formatted string. If the number cannot be parsed, then zero is returned by default.
+ * Ex: $1,000.20 => 1000.2
+ * @param str
+ */
+export declare function toNumber(str?: string | number | null): number;
+/**
+ * Get a number value from a formatted string. If the number cannot be parsed, then null is returned by default.
+ * Ex: $1,000.20 => 1000.2
+ * @param str
+ */
+export declare function toNumberOrNull(str?: string | number | null): number | null;
+/**
+ * Get a currency value from a string or number. If the number cannot be parsed, then null is returned by default.
+ * Ex: 1000.20 => $1,000.20
+ * @param value The value to be converted to a currency.
+ */
+export declare function toCurrencyOrNull(value?: string | number | null): string | null;
+/**
+ * Adds an ordinal suffix.
+ * Ex: 1 => 1st
+ * @param num
+ */
+export declare function toOrdinalSuffix(num?: number | null): string;
+/**
+ * Convert a number to an ordinal.
+ * Ex: 1 => first
+ * @param num
+ */
+export declare function toOrdinal(num?: number | null): string;
+/**
+ * Convert a number to a word.
+ * Ex: 1 => one
+ * @param num
+ */
+export declare function toWord(num?: number | null): string;
+export declare function zeroPad(num: number, length: number): string;
+export declare function toDecimalPlaces(num: number, decimalPlaces: number): number;
+declare const _default: {
+    toOrdinal: typeof toOrdinal;
+    toOrdinalSuffix: typeof toOrdinalSuffix;
+    toNumberOrNull: typeof toNumberOrNull;
+    asFormattedString: typeof asFormattedString;
+};
+export default _default;

package/types/Utility/objectUtils.d.ts

@@ -0,0 +1 @@
+export declare function fromEntries(entries: Iterable<[PropertyKey, string]>): Record<string, unknown>;

package/types/Utility/page.d.ts

@@ -0,0 +1,49 @@
+import { Guid } from "@Obsidian/Types";
+import { CurrentPersonBag } from "@Obsidian/ViewModels/Crm/currentPersonBag";
+export declare type PageConfig = {
+    executionStartTime: number;
+    pageId: number;
+    pageGuid: Guid;
+    pageParameters: Record<string, string>;
+    currentPerson: CurrentPersonBag | null;
+    isAnonymousVisitor: boolean;
+    loginUrlWithReturnUrl: string;
+};
+export declare function smoothScrollToTop(): void;
+declare const _default: {
+    smoothScrollToTop: typeof smoothScrollToTop;
+};
+export default _default;
+/**
+ * Track a modal being opened or closed. This is used to adjust the page in response
+ * to any modals being visible.
+ *
+ * @param state true if the modal is now open, false if it is now closed.
+ */
+export declare function trackModalState(state: boolean): void;
+/**
+ * Loads a JavaScript file asynchronously into the document and returns a
+ * Promise that can be used to determine when the script has loaded. The
+ * promise will return true if the script loaded successfully or false if it
+ * failed to load.
+ *
+ * The function passed in isScriptLoaded will be called before the script is
+ * inserted into the DOM as well as after to make sure it actually loaded.
+ *
+ * @param source The source URL of the script to be loaded.
+ * @param isScriptLoaded An optional function to call to determine if the script is loaded.
+ * @param attributes An optional set of attributes to apply to the script tag.
+ * @param fingerprint If set to false, then a fingerprint will not be added to the source URL. Default is true.
+ *
+ * @returns A Promise that indicates if the script was loaded or not.
+ */
+export declare function loadJavaScriptAsync(source: string, isScriptLoaded?: () => boolean, attributes?: Record<string, string>, fingerprint?: boolean): Promise<boolean>;
+/**
+ * Adds a new link to the quick return action menu. The URL in the address bar
+ * will be used as the destination.
+ *
+ * @param title The title of the quick link that identifies the current page.
+ * @param section The section title to place this link into.
+ * @param sectionOrder The priority order to give the section if it doesn't already exist.
+ */
+export declare function addQuickReturn(title: string, section: string, sectionOrder?: number): void;

package/types/Utility/phone.d.ts

@@ -0,0 +1,28 @@
+import { PhoneNumberBoxGetConfigurationResultsBag } from "@Obsidian/ViewModels/Rest/Controls/phoneNumberBoxGetConfigurationResultsBag";
+import { PhoneNumberCountryCodeRulesConfigurationBag } from "@Obsidian/ViewModels/Rest/Controls/phoneNumberCountryCodeRulesConfigurationBag";
+/**
+ * Fetch the configuration for phone numbers and their possible formats for different countries.
+ * Cacheable version of fetchPhoneNumberConfiguration cacheable
+ */
+export declare const getPhoneNumberConfiguration: () => Promise<PhoneNumberBoxGetConfigurationResultsBag>;
+export declare const getPhoneNumberAndSmsConfiguration: () => Promise<PhoneNumberBoxGetConfigurationResultsBag>;
+/**
+ * Format a phone number according to a given configuration
+ *
+ * e.g. from the default configuration:
+ * 3214567 => 321-4567
+ * 3214567890 => (321) 456-7890
+ */
+export declare function formatPhoneNumber(value: string, rules?: PhoneNumberCountryCodeRulesConfigurationBag[]): string;
+/**
+ * Strips special characters from the phone number.
+ * (321) 456-7890 => 3214567890
+ * @param str
+ */
+export declare function stripPhoneNumber(str: string): string;
+declare const _default: {
+    getPhoneNumberConfiguration: () => Promise<PhoneNumberBoxGetConfigurationResultsBag>;
+    formatPhoneNumber: typeof formatPhoneNumber;
+    stripPhoneNumber: typeof stripPhoneNumber;
+};
+export default _default;

package/types/Utility/popover.d.ts

@@ -0,0 +1,16 @@
+declare type PopoverOptions = {
+    /** Allow HTML content in the popover. */
+    html?: boolean;
+    /** Enables santization of HTML content. */
+    sanitize?: boolean;
+};
+/**
+ * Configure a popover for the specified node or nodes to show on hover. This
+ * currently uses Bootstrap popovers but may be changed to use a different
+ * method later.
+ *
+ * @param node The node or nodes to have popovers configured on.
+ * @param options The options that describe how the popovers should behave.
+ */
+export declare function popover(node: Element | Element[], options?: PopoverOptions): void;
+export {};

package/types/Utility/promiseUtils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Returns a promise that completes after the specified number of milliseconds
+ * have ellapsed.
+ *
+ * @param ms The number of milliseconds to wait.
+ *
+ * @returns A promise that completes after the interval has ellapsed.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Checks if the value is a promise to return a value. This is used to check
+ * if a function that could have returned either a value or a promise for a
+ * value returned a promise.
+ *
+ * @param obj The object to be tested if it is a promise.
+ *
+ * @returns True if the object is a promise.
+ */
+export declare function isPromise<T>(obj: PromiseLike<T> | T): obj is PromiseLike<T>;
+/**
+ * A class that provides a way to defer execution via await until some
+ * external trigger happens.
+ */
+export declare class PromiseCompletionSource<T = void> {
+    private internalPromise;
+    private internalResolve;
+    private internalReject;
+    constructor();
+    /** The promise that can be awaited. */
+    get promise(): Promise<T>;
+    /**
+     * Resolves the promise with the given value.
+     *
+     * @param value The value to be returned by the await call.
+     */
+    resolve(value: T): void;
+    /**
+     * Rejects the promise and throws the reason as an error.
+     *
+     * @param reason The reason to be thrown by the await call.
+     */
+    reject(reason?: unknown): void;
+}

package/types/Utility/realTime.d.ts

@@ -0,0 +1,79 @@
+/** A generic set a server functions with no type checking. */
+export declare type GenericServerFunctions = {
+    [name: string]: (...args: unknown[]) => unknown;
+};
+/** A set of specific server functions that conform to an interface. */
+export declare type ServerFunctions<T> = {
+    [K in keyof T]: T[K] extends Function ? T[K] : never;
+};
+/**
+ * An object that allows RealTime communication between the browser and the Rock
+ * server over a specific topic.
+ */
+export interface ITopic<TServer extends ServerFunctions<TServer> = GenericServerFunctions> {
+    /**
+     * Allows messages to be sent to the server. Any property access is treated
+     * like a message function whose property name is the message name.
+     */
+    server: TServer;
+    /**
+     * Gets the connection identifier for this topic. This will be the same for
+     * all topics, but that should not be relied on staying that way in the future.
+     */
+    get connectionId(): string | null;
+    /**
+     * Gets a value that indicates if the topic is currently reconnecting.
+     */
+    get isReconnecting(): boolean;
+    /**
+     * Gets a value that indicates if the topic is disconnected and will no
+     * longer try to connect to the server.
+     */
+    get isDisconnected(): boolean;
+    /**
+     * Registers a handler to be called when a message with the given name
+     * is received.
+     *
+     * @param messageName The message name that will trigger the handler.
+     * @param handler The handler to be called when a message is received.
+     */
+    on(messageName: string, handler: ((...args: any[]) => void)): void;
+    /**
+     * Registers a handler to be called when any message is received.
+     *
+     * @param handler The handler to be called when a message is received.
+     */
+    onMessage(handler: ((messageName: string, args: unknown[]) => void)): void;
+    /**
+     * Registers a callback to be called when the connection has been
+     * temporarily lost. An automatic reconnection is in progress. The topic
+     * is now in a state where it can not send any messages.
+     *
+     * @param callback The callback to be called.
+     */
+    onReconnecting(callback: (() => void)): void;
+    /**
+     * Registers a callback to be called when the connection has been
+     * reconnected. The topic can now send messages again.
+     *
+     * @param callback The callback to be called.
+     */
+    onReconnected(callback: (() => void)): void;
+    /**
+     * Registers a callback to be called when the connection has been lost
+     * and will no longer try to reconnect.
+     *
+     * @param callback The callback to be called.
+     */
+    onDisconnected(callback: (() => void)): void;
+}
+/**
+ * Connects to a specific topic in the Rock RealTime system and returns an
+ * instance to a proxy that handles sending to and receiving messages from
+ * that specific topic.
+ *
+ * @param identifier The identifier of the topic to be connected to.
+ *
+ * @returns A proxy to handle communication with the topic.
+ */
+export declare function getTopic<TServer extends ServerFunctions<TServer>>(identifier: string): Promise<ITopic<TServer>>;

package/types/Utility/rockDateTime.d.ts

@@ -0,0 +1,316 @@
+import { DayOfWeek } from "@Obsidian/Enums/Controls/dayOfWeek";
+/**
+ * The days of the week that are used by RockDateTime.
+ */
+export { DayOfWeek } from "@Obsidian/Enums/Controls/dayOfWeek";
+/**
+ * The various date and time formats supported by the formatting methods.
+ */
+export declare const DateTimeFormat: Record<string, Intl.DateTimeFormatOptions>;
+/**
+ * A date and time object that handles time zones and formatting. This class is
+ * immutable and cannot be modified. All modifications are performed by returning
+ * a new RockDateTime instance.
+ */
+export declare class RockDateTime {
+    /** The internal DateTime object that holds our date information. */
+    private dateTime;
+    /**
+     * Creates a new instance of RockDateTime.
+     *
+     * @param dateTime The Luxon DateTime object that is used to track the internal state.
+     */
+    private constructor();
+    /**
+     * Creates a new instance of RockDateTime from the given date and time parts.
+     *
+     * @param year The year of the new date.
+     * @param month The month of the new date (1-12).
+     * @param day The day of month of the new date.
+     * @param hour The hour of the day.
+     * @param minute The minute of the hour.
+     * @param second The second of the minute.
+     * @param millisecond The millisecond of the second.
+     * @param zone The time zone offset to construct the date in.
+     *
+     * @returns A RockDateTime instance or null if the requested date was not valid.
+     */
+    static fromParts(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millisecond?: number, zone?: number | string): RockDateTime | null;
+    /**
+     * Creates a new instance of RockDateTime that represents the time specified
+     * as the Javascript milliseconds value. The time zone is set to the browser
+     * time zone.
+     *
+     * @param milliseconds The time in milliseconds since the epoch.
+     *
+     * @returns A new RockDateTime instance or null if the specified date was not valid.
+     */
+    static fromMilliseconds(milliseconds: number): RockDateTime | null;
+    /**
+     * Construct a new RockDateTime instance from a Javascript Date object.
+     *
+     * @param date The Javascript date object that contains the date information.
+     *
+     * @returns A RockDateTime instance or null if the date was not valid.
+     */
+    static fromJSDate(date: Date): RockDateTime | null;
+    /**
+     * Constructs a new RockDateTime instance by parsing the given string from
+     * ISO 8601 format.
+     *
+     * @param dateString The string that contains the ISO 8601 formatted text.
+     *
+     * @returns A new RockDateTime instance or null if the date was not valid.
+     */
+    static parseISO(dateString: string): RockDateTime | null;
+    /**
+     * Constructs a new RockDateTime instance by parsing the given string from
+     * RFC 1123 format. This is common in HTTP headers.
+     *
+     * @param dateString The string that contains the RFC 1123 formatted text.
+     *
+     * @returns A new RockDateTime instance or null if the date was not valid.
+     */
+    static parseHTTP(dateString: string): RockDateTime | null;
+    /**
+     * Creates a new RockDateTime instance that represents the current date and time.
+     *
+     * @returns A RockDateTime instance.
+     */
+    static now(): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the current time in UTC.
+     *
+     * @returns A new RockDateTime instance in the UTC time zone.
+     */
+    static utcNow(): RockDateTime;
+    /**
+     * The Date portion of this RockDateTime instance. All time properties of
+     * the returned instance will be set to 0.
+     */
+    get date(): RockDateTime;
+    /**
+     * The day of the month represented by this instance.
+     */
+    get day(): number;
+    /**
+     * The day of the week represented by this instance.
+     */
+    get dayOfWeek(): DayOfWeek;
+    /**
+     * The day of the year represented by this instance.
+     */
+    get dayOfYear(): number;
+    /**
+     * The hour of the day represented by this instance.
+     */
+    get hour(): number;
+    /**
+     * The millisecond of the second represented by this instance.
+     */
+    get millisecond(): number;
+    /**
+     * The minute of the hour represented by this instance.
+     */
+    get minute(): number;
+    /**
+     * The month of the year represented by this instance (1-12).
+     */
+    get month(): number;
+    /**
+     * The offset from UTC represented by this instance. If the timezone of this
+     * instance is UTC-7 then the value returned is -420.
+     */
+    get offset(): number;
+    /**
+     * The second of the minute represented by this instance.
+     */
+    get second(): number;
+    /**
+     * The year represented by this instance.
+     */
+    get year(): number;
+    /**
+     * Creates a new RockDateTime instance that represents the same point in
+     * time represented in the local browser time zone.
+     */
+    get localDateTime(): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the same point in
+     * time represented in the organization time zone.
+     */
+    get organizationDateTime(): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the same point in
+     * time represented in UTC.
+     */
+    get universalDateTime(): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of days to this instance.
+     *
+     * @param days The number of days to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addDays(days: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of hours to this instance.
+     *
+     * @param days The number of hours to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addHours(hours: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of milliseconds to this instance.
+     *
+     * @param days The number of milliseconds to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addMilliseconds(milliseconds: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of minutes to this instance.
+     *
+     * @param days The number of minutes to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addMinutes(minutes: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of months to this instance.
+     *
+     * @param days The number of months to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addMonths(months: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of seconds to this instance.
+     *
+     * @param days The number of seconds to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addSeconds(seconds: number): RockDateTime;
+    /**
+     * Creates a new RockDateTime instance that represents the date and time
+     * after adding the number of years to this instance.
+     *
+     * @param days The number of years to add.
+     *
+     * @returns A new instance of RockDateTime that represents the new date and time.
+     */
+    addYears(years: number): RockDateTime;
+    /**
+     * Converts the date time representation into the number of milliseconds
+     * that have elapsed since the epoch (1970-01-01T00:00:00Z).
+     *
+     * @returns The number of milliseconds since the epoch.
+     */
+    toMilliseconds(): number;
+    /**
+     * Creates a new instance of RockDateTime that represents the same point
+     * in time as represented by the specified time zone offset.
+     *
+     * @param zone The time zone offset as a number or string such as "UTC+4".
+     *
+     * @returns A new RockDateTime instance that represents the specified time zone.
+     */
+    toOffset(zone: number | string): RockDateTime;
+    /**
+     * Formats this instance according to C# formatting rules.
+     *
+     * @param format The string that specifies the format to use.
+     *
+     * @returns A string representing this instance in the given format.
+     */
+    toASPString(format: string): string;
+    /**
+     * Creates a string representation of this instance in ISO8601 format.
+     *
+     * @returns An ISO8601 formatted string.
+     */
+    toISOString(): string;
+    /**
+     * Formats this instance using standard locale formatting rules to display
+     * a date and time in the browsers specified locale.
+     *
+     * @param format The format to use when generating the string.
+     *
+     * @returns A string that represents the date and time in then specified format.
+     */
+    toLocaleString(format: Intl.DateTimeFormatOptions): string;
+    /**
+     * Transforms the date into a human friendly elapsed time string.
+     *
+     * @example
+     * // Returns "21yrs"
+     * RockDateTime.fromParts(2000, 3, 4).toElapsedString();
+     *
+     * @returns A string that represents the amount of time that has elapsed.
+     */
+    toElapsedString(): string;
+    /**
+     * Formats this instance as a string that can be used in HTTP headers and
+     * cookies.
+     *
+     * @returns A new string that conforms to RFC 1123
+     */
+    toHTTPString(): string;
+    /**
+     * Get the value of the date and time in a format that can be used in
+     * comparisons.
+     *
+     * @returns A number that represents the date and time.
+     */
+    valueOf(): number;
+    /**
+     * Creates a standard string representation of the date and time.
+     *
+     * @returns A string representation of the date and time.
+     */
+    toString(): string;
+    /**
+     * Checks if this instance is equal to another RockDateTime instance. This
+     * will return true if the two instances represent the same point in time,
+     * even if they have been associated with different time zones. In other
+     * words "2021-09-08 12:00:00 Z" == "2021-09-08 14:00:00 UTC+2".
+     *
+     * @param otherDateTime The other RockDateTime to be compared against.
+     *
+     * @returns True if the two instances represent the same point in time.
+     */
+    isEqualTo(otherDateTime: RockDateTime): boolean;
+    /**
+     * Checks if this instance is later than another RockDateTime instance.
+     *
+     * @param otherDateTime The other RockDateTime to be compared against.
+     *
+     * @returns True if this instance represents a point in time that occurred after another point in time, regardless of time zone.
+     */
+    isLaterThan(otherDateTime: RockDateTime): boolean;
+    /**
+     * Checks if this instance is earlier than another RockDateTime instance.
+     *
+     * @param otherDateTime The other RockDateTime to be compared against.
+     *
+     * @returns True if this instance represents a point in time that occurred before another point in time, regardless of time zone.
+     */
+    isEarlierThan(otherDateTime: RockDateTime): boolean;
+    /**
+     * Calculates the elapsed time between this date and the reference date and
+     * returns that difference in a human friendly way.
+     *
+     * @param otherDateTime The reference date and time. If not specified then 'now' is used.
+     *
+     * @returns A string that represents the elapsed time.
+     */
+    humanizeElapsed(otherDateTime?: RockDateTime): string;
+}

package/types/Utility/slidingDateRange.d.ts

@@ -0,0 +1,82 @@
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+import { SlidingDateRangeType as RangeType } from "@Obsidian/Enums/Controls/slidingDateRangeType";
+import { TimeUnitType as TimeUnit } from "@Obsidian/Enums/Controls/timeUnitType";
+import { RockDateTime } from "./rockDateTime";
+/**
+ * The enums have been moved to separate files in order to share with the back end. We import them
+ * above (with the names used by the definitions that used to exist in this file) so they can be
+ * used below and we export them here so that any files previously importing them from here
+ * do not break.
+ */
+export { SlidingDateRangeType as RangeType } from "@Obsidian/Enums/Controls/slidingDateRangeType";
+export { TimeUnitType as TimeUnit } from "@Obsidian/Enums/Controls/timeUnitType";
+/**
+ * Specifies the information required to track a sliding date range.
+ */
+export declare type SlidingDateRange = {
+    /** The type of sliding date range represented by this instance. */
+    rangeType: RangeType;
+    /** The unit of time represented by the timeValue property. */
+    timeUnit?: TimeUnit;
+    /** The number of time units used when calculating the date range. */
+    timeValue?: number;
+    /** The lower value of a specific date range. */
+    lowerDate?: string;
+    /** The upper value of a specific date range. */
+    upperDate?: string;
+};
+/**
+ * The sliding date range types represented as an array of ListItemBag objects.
+ * These are ordered correctly and can be used in pickers.
+ */
+export declare const rangeTypeOptions: ListItemBag[];
+/**
+ * The sliding date range time units represented as an array of ListItemBag objects.
+ * These are ordered correctly and can be used in pickers.
+ */
+export declare const timeUnitOptions: ListItemBag[];
+/**
+ * Gets the user friendly text that represents the RangeType value.
+ *
+ * @param rangeType The RangeType value to be represented.
+ *
+ * @returns A human readable string that represents the RangeType value.
+ */
+export declare function getRangeTypeText(rangeType: RangeType): string;
+/**
+ * Gets the user friendly text that represents the TimeUnit value.
+ *
+ * @param timeUnit The TimeUnit value to be represented.
+ *
+ * @returns A human readable string that represents the TimeUnit value.
+ */
+export declare function getTimeUnitText(timeUnit: TimeUnit): string;
+/**
+ * Parses a pipe delimited string into a SlidingDateRange native object. The
+ * delimited string is a format used by attribute values and other places.
+ *
+ * @param value The pipe delimited string that should be parsed.
+ *
+ * @returns A SlidingDaterange object or null if the string could not be parsed.
+ */
+export declare function parseSlidingDateRangeString(value: string): SlidingDateRange | null;
+/**
+ * Formats the pipe delimited string.
+ *
+ * @param value The pipe delimited string that should be formatted.
+ *
+ * @returns A string that formats the sliding date range.
+ */
+export declare function slidingDateRangeToString(value: SlidingDateRange): string;
+/**
+ * Calculates the start and end dates in a sliding date range.
+ *
+ * @param value The sliding date range to use when calculating dates.
+ * @param currentDateTime The date and time to use in any "now" calculations.
+ *
+ * @returns An object that contains the start and end dates and times.
+ */
+export declare function calculateSlidingDateRange(value: SlidingDateRange, currentDateTime?: RockDateTime | null | undefined): {
+    start: RockDateTime | null;
+    end: RockDateTime | null;
+};