@rockrms/obsidian-framework 1.16.3-rc.1

package/types/Utility/form.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Holds the state of a single form on the page along with any callback methods
+ * that can be used to interact with the form.
+ */
+export declare type FormState = {
+    /** The number of submissions the form has had. */
+    submitCount: number;
+    /** Sets the current error for the given field name. A blank error means no error. */
+    setError: (id: string, name: string, error: string) => void;
+};
+/**
+ * Contains the internal form error passed between RockForm and RockValidation.
+ *
+ * This is an internal type and subject to change at any time.
+ */
+export declare type FormError = {
+    /** The name of the field. */
+    name: string;
+    /** The current error text. */
+    text: string;
+};
+/**
+ * Provides the form state for any child components that need access to it.
+ *
+ * @param state The state that will be provided to child components.
+ */
+export declare function provideFormState(state: FormState): void;
+/**
+ * Makes use of the FormState that was previously provided by a parent component.
+ *
+ * @returns The form state or undefined if it was not available.
+ */
+export declare function useFormState(): FormState | undefined;

package/types/Utility/fullscreen.d.ts

@@ -0,0 +1,33 @@
+declare global {
+    interface Document {
+        mozCancelFullScreen?: () => Promise<void>;
+        webkitExitFullscreen?: () => Promise<void>;
+        mozFullScreenElement?: Element;
+        webkitFullscreenElement?: Element;
+    }
+    interface HTMLElement {
+        mozRequestFullscreen?: () => Promise<void>;
+        webkitRequestFullscreen?: () => Promise<void>;
+    }
+}
+/**
+ * Request that the window enter true fullscreen mode for the given element.
+ *
+ * @param element The element that will be the root of the fullscreen view.
+ * @param exitCallback The function to call when leaving fullscreen mode.
+ *
+ * @returns A promise that indicates when the operation has completed.
+ */
+export declare function enterFullscreen(element: HTMLElement, exitCallback?: (() => void)): Promise<boolean>;
+/**
+ * Checks if any element is currently in fullscreen mode.
+ *
+ * @returns True if an element is currently in fullscreen mode in the window; otherwise false.
+ */
+export declare function isFullscreen(): boolean;
+/**
+ * Manually exits fullscreen mode.
+ *
+ * @returns True if fullscreen mode was exited; otherwise false.
+ */
+export declare function exitFullscreen(): Promise<boolean>;

package/types/Utility/geo.d.ts

@@ -0,0 +1,45 @@
+import { DrawingMode, Coordinate, ILatLng, ILatLngLiteral } from "@Obsidian/Types/Controls/geo";
+import { GeoPickerSettingsBag } from "@Obsidian/ViewModels/Rest/Controls/geoPickerSettingsBag";
+import { GeoPickerGetSettingsOptionsBag } from "@Obsidian/ViewModels/Rest/Controls/geoPickerGetSettingsOptionsBag";
+/**
+ * Converts a LatLng object, "lat,lng" coordinate string, or WellKnown "lng lat" coordinate string to a Coordinate array
+ * @param coord Either a string in "lat,lng" format or a LatLng object from Google Maps
+ * @param isWellKnown True if is "lng lat" format, false if it is "lat, lng"
+ *
+ * @returns Coordinate: Tuple with a Latitude number and Longitude number as the elements
+ */
+export declare function toCoordinate(coord: string | ILatLng, isWellKnown?: boolean): Coordinate;
+/**
+ * Takes a Well Known Text value and converts it into a Coordinate array
+ */
+export declare function wellKnownToCoordinates(wellKnownText: string, type: DrawingMode): Coordinate[];
+/**
+ * Takes a Well Known Text value and converts it into a Coordinate array
+ */
+export declare function coordinatesToWellKnown(coordinates: Coordinate[], type: DrawingMode): string;
+/**
+ * Takes a Coordinate and uses Geocoding to get nearest address
+ */
+export declare function nearAddressForCoordinate(coordinate: Coordinate): Promise<string>;
+/**
+ * Takes a Coordinate array and uses Geocoding to get nearest address for the first point
+ */
+export declare function nearAddressForCoordinates(coordinates: Coordinate[]): Promise<string>;
+/**
+ * Determine whether the polygon's coordinates are drawn in clockwise order
+ * Thank you dominoc!
+ * http://dominoc925.blogspot.com/2012/03/c-code-to-determine-if-polygon-vertices.html
+ */
+export declare function isClockwisePolygon(polygon: number[][]): boolean;
+/**
+ * Download the necessary resources to run the maps and return the map settings from the API
+ *
+ * @param options Options for which data to get from the API
+ *
+ * @return Promise with the map settings retrieved from the API
+ */
+export declare function loadMapResources(options?: GeoPickerGetSettingsOptionsBag): Promise<GeoPickerSettingsBag>;
+/**
+ * Creates a ILatLng object
+ */
+export declare function createLatLng(latOrLatLngOrLatLngLiteral: number | ILatLngLiteral | ILatLng, lngOrNoClampNoWrap?: number | boolean | null, noClampNoWrap?: boolean): ILatLng;

package/types/Utility/guid.d.ts

@@ -0,0 +1,39 @@
+import { Guid } from "@Obsidian/Types";
+/** An empty unique identifier. */
+export declare const emptyGuid = "00000000-0000-0000-0000-000000000000";
+/**
+* Generates a new Guid
+*/
+export declare function newGuid(): Guid;
+/**
+ * Returns a normalized Guid that can be compared with string equality (===)
+ * @param a
+ */
+export declare function normalize(a: Guid | null | undefined): Guid | null;
+/**
+ * Checks if the given string is a valid Guid. To be considered valid it must
+ * be a bare guid with hyphens. Bare means not enclosed in '{' and '}'.
+ *
+ * @param guid The Guid to be checked.
+ * @returns True if the guid is valid, otherwise false.
+ */
+export declare function isValidGuid(guid: Guid | string): boolean;
+/**
+ * Converts the string value to a Guid.
+ *
+ * @param value The value to be converted.
+ * @returns A Guid value or null is the string could not be parsed as a Guid.
+ */
+export declare function toGuidOrNull(value: string | null | undefined): Guid | null;
+/**
+ * Are the guids equal?
+ * @param a
+ * @param b
+ */
+export declare function areEqual(a: Guid | null | undefined, b: Guid | null | undefined): boolean;
+declare const _default: {
+    newGuid: typeof newGuid;
+    normalize: typeof normalize;
+    areEqual: typeof areEqual;
+};
+export default _default;

package/types/Utility/http.d.ts

@@ -0,0 +1,94 @@
+import { Guid } from "@Obsidian/Types";
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+import { HttpBodyData, HttpMethod, HttpFunctions, HttpResult, HttpUrlParams } from "@Obsidian/Types/Utility/http";
+/**
+ * Make an API call.  This is a special use function that should not
+ * normally be used. Instead call useHttp() to get the HTTP functions that
+ * can be used.
+ *
+ * @param {string} method The HTTP method, such as GET
+ * @param {string} url The endpoint to access, such as /api/campuses/
+ * @param {object} params Query parameter object.  Will be converted to ?key1=value1&key2=value2 as part of the URL.
+ * @param {any} data This will be the body of the request
+ */
+export declare function doApiCall<T>(method: HttpMethod, url: string, params?: HttpUrlParams, data?: HttpBodyData): Promise<HttpResult<T>>;
+/**
+ * Make a GET HTTP request. This is a special use function that should not
+ * normally be used. Instead call useHttp() to get the HTTP functions that
+ * can be used.
+ *
+ * @param {string} url The endpoint to access, such as /api/campuses/
+ * @param {object} params Query parameter object.  Will be converted to ?key1=value1&key2=value2 as part of the URL.
+ */
+export declare function get<T>(url: string, params?: HttpUrlParams): Promise<HttpResult<T>>;
+/**
+ * Make a POST HTTP request. This is a special use function that should not
+ * normally be used. Instead call useHttp() to get the HTTP functions that
+ * can be used.
+ *
+ * @param {string} url The endpoint to access, such as /api/campuses/
+ * @param {object} params Query parameter object.  Will be converted to ?key1=value1&key2=value2 as part of the URL.
+ * @param {any} data This will be the body of the request
+ */
+export declare function post<T>(url: string, params?: HttpUrlParams, data?: HttpBodyData): Promise<HttpResult<T>>;
+/**
+ * Provides the HTTP functions that child components will use. This is an
+ * internal API and should not be used by third party components.
+ *
+ * @param functions The functions that will be made available to child components.
+ */
+export declare function provideHttp(functions: HttpFunctions): void;
+/**
+ * Gets the HTTP functions that can be used by the component. This is the
+ * standard way to make HTTP requests.
+ *
+ * @returns An object that contains the functions which can be called.
+ */
+export declare function useHttp(): HttpFunctions;
+/**
+ * Progress reporting callback used when uploading a file into Rock.
+ */
+export declare type UploadProgressCallback = (progress: number, total: number, percent: number) => void;
+/**
+ * Options used when uploading a file into Rock to change the default behavior.
+ */
+export declare type UploadOptions = {
+    /**
+     * The base URL to use when uploading the file, must accept the same parameters
+     * and as the standard FileUploader.ashx handler.
+     */
+    baseUrl?: string;
+    /** True if the file should be uploaded as temporary, only applies to binary files. */
+    isTemporary?: boolean;
+    /** A function to call to report the ongoing progress of the upload. */
+    progress: UploadProgressCallback;
+};
+/**
+ * Uploads a file to the Rock file system, usually inside the ~/Content directory.
+ *
+ * @param file The file to be uploaded to the server.
+ * @param encryptedRootFolder The encrypted root folder specified by the server,
+ * this specifies the jail the upload operation is limited to.
+ * @param folderPath The additional sub-folder path to use inside the root folder.
+ * @param options The options to use when uploading the file.
+ *
+ * @returns A ListItemBag that contains the scrubbed filename that was uploaded.
+ */
+export declare function uploadContentFile(file: File, encryptedRootFolder: string, folderPath: string, options?: UploadOptions): Promise<ListItemBag>;
+/**
+ * Uploads a BinaryFile into Rock. The specific storage location is defined by
+ * the file type.
+ *
+ * @param file The file to be uploaded into Rock.
+ * @param binaryFileTypeGuid The unique identifier of the BinaryFileType to handle the upload.
+ * @param options The options ot use when uploading the file.
+ *
+ * @returns A ListItemBag whose value contains the new file Guid and text specifies the filename.
+ */
+export declare function uploadBinaryFile(file: File, binaryFileTypeGuid: Guid, options?: UploadOptions): Promise<ListItemBag>;
+declare const _default: {
+    doApiCall: typeof doApiCall;
+    post: typeof post;
+    get: typeof get;
+};
+export default _default;

package/types/Utility/internetCalendar.d.ts

@@ -0,0 +1,242 @@
+import { DayOfWeek, RockDateTime } from "./rockDateTime";
+declare type Frequency = "DAILY" | "WEEKLY" | "MONTHLY";
+/**
+ * The day of the week and an interval number for that particular day.
+ */
+export declare type WeekdayNumber = {
+    /** The interval number for this day. */
+    value: number;
+    /** The day of the week. */
+    day: DayOfWeek;
+};
+/**
+ * Helper utility to feed lines into ICS parsers.
+ */
+declare class LineFeeder {
+    /**
+     * The denormalzied lines that represent the ICS data.
+     */
+    private lines;
+    /**
+     * Creates a new LineFeeder with the given content.
+     *
+     * @param content A string that represents raw ICS data.
+     */
+    constructor(content: string);
+    /**
+     * Peek at the next line to be read from the feeder.
+     *
+     * @returns The next line to be read or null if no more lines remain.
+     */
+    peek(): string | null;
+    /**
+     * Pops the next line from the feeder, removing it.
+     *
+     * @returns The line that was removed from the feeder or null if no lines remain.
+     */
+    pop(): string | null;
+}
+/**
+ * Logic and structure for a rule that defines when an even recurs on
+ * different dates.
+ */
+export declare class RecurrenceRule {
+    /**
+     * The frequency of this recurrence. Only Daily, Weekly and Monthly
+     * are supported.
+     */
+    frequency?: Frequency;
+    /**
+     * The date at which no more event dates will be generated. This is
+     * an exclusive date, meaning if an event date lands on this date
+     * then it will not be included in the list of dates.
+     */
+    endDate?: RockDateTime;
+    /**
+     * The maximum number of dates, including the original date, that
+     * should be generated.
+     */
+    count?: number;
+    /**
+     * The interval between dates based on the frequency. If this value is
+     * 2 and frequency is Weekly, then you are asking for "every other week".
+     */
+    interval: number;
+    /**
+     * The days of the month the event should recur on. Only a single value
+     * is supported currently.
+     */
+    byMonthDay: number[];
+    /**
+     * The days of the week the event shoudl recur on.
+     */
+    byDay: WeekdayNumber[];
+    /**
+     * Creates a new recurrence rule that can be used to define or adjust the
+     * recurrence pattern of an event.
+     *
+     * @param rule An existing RRULE string from an iCal file.
+     *
+     * @returns A new instance that can be used to adjust or define the rule.
+     */
+    constructor(rule?: string | undefined);
+    /**
+     * Builds and returns the RRULE value for an iCal file export.
+     *
+     * @returns A RRULE value that represents the recurrence rule.
+     */
+    build(): string;
+    /**
+     * Gets all the dates within the range that match the recurrence rule. A
+     * maximum of 100,000 dates will be returned by this function.
+     *
+     * @param eventStartDateTime The start date and time of the primary event this rule is for.
+     * @param startDateTime The inclusive starting date and time that events should be returned for.
+     * @param endDateTime The exclusive ending date and time that events should be returned for.
+     *
+     * @returns An array of date objects that represent the additional dates and times for the event.
+     */
+    getDates(eventStartDateTime: RockDateTime, startDateTime: RockDateTime, endDateTime: RockDateTime): RockDateTime[];
+    /**
+     * Gets the next valid date after the specified date based on our recurrence
+     * rules.
+     *
+     * @param rockDate The reference date that should be used when calculation the next date.
+     *
+     * @returns The next date after the reference date or null if one cannot be determined.
+     */
+    private nextDateAfter;
+}
+/**
+ * A single event inside a calendar.
+ */
+export declare class Event {
+    /**
+     * The unique identifier for this schedule used in the scheduled event.
+     */
+    uid?: string;
+    /**
+     * The first date and time that the event occurs on. This must be provided
+     * before the schedule can be built.
+     */
+    startDateTime?: RockDateTime;
+    /**
+     * The end date and time for the event. This must be provided before
+     * this schedule can be built.
+     */
+    endDateTime?: RockDateTime;
+    /**
+     * An array of dates to be excluded from the recurrence rules.
+     */
+    excludedDates: RockDateTime[];
+    /**
+     * An array of specific dates that this schedule will recur on. This is
+     * only valid if recurrenceRules contains no rules.
+     */
+    recurrenceDates: RockDateTime[];
+    /**
+     * The rules that define when this schedule recurs on for additional dates.
+     * Only the first rule is currently supported.
+     */
+    recurrenceRules: RecurrenceRule[];
+    /**
+     * Creates a new internet calendar event.
+     *
+     * @param icsContent The content from the ICS file that represents this single event.
+     *
+     * @returns A new Event instance.
+     */
+    constructor(icsContent?: string | LineFeeder | undefined);
+    /**
+     * Build the event as a list of individual lines that make up the event in
+     * the ICS file format.
+     *
+     * @returns An array of lines to be inserted into an ICS file.
+     */
+    buildLines(): string[];
+    /**
+     * Builds the event into a string that conforms to ICS format.
+     *
+     * @returns An ICS formatted string that represents the event data.
+     */
+    build(): string | null;
+    /**
+     * Parse data from an existing event and store it on this instance.
+     *
+     * @param feeder The feeder that will provide the line data for parsing.
+     */
+    private parse;
+    /**
+     * Determines if the date is listed in one of the excluded dates. This
+     * currently only checks the excludedDates but in the future might also
+     * check the excluded rules.
+     *
+     * @param rockDate The date to be checked to see if it is excluded.
+     *
+     * @returns True if the date is excluded; otherwise false.
+     */
+    private isDateExcluded;
+    /**
+     * Get all the dates for this event that fall within the specified date range.
+     *
+     * @param startDateTime The inclusive starting date to use when filtering event dates.
+     * @param endDateTime The exclusive endign date to use when filtering event dates.
+     *
+     * @returns An array of dates that fall between startDateTime and endDateTime.
+     */
+    getDates(startDateTime: RockDateTime, endDateTime: RockDateTime): RockDateTime[];
+    /**
+     * Get the friendly text string that represents this event. This will be a
+     * plain text string with no formatting applied.
+     *
+     * @returns A string that represents the event in a human friendly manner.
+     */
+    toFriendlyText(): string;
+    /**
+     * Get the friendly HTML string that represents this event. This will be
+     * formatted with HTML to make the information easier to read.
+     *
+     * @returns A string that represents the event in a human friendly manner.
+     */
+    toFriendlyHtml(): string;
+    /**
+     * Get the friendly string that can be easily understood by a human.
+     *
+     * @param html If true then the string can contain HTML content to make things easier to read.
+     *
+     * @returns A string that represents the event in a human friendly manner.
+     */
+    private toFriendlyString;
+}
+/**
+ * A recurring schedule allows schedules to be built and customized from the iCal
+ * format used in ics files.
+ */
+export declare class Calendar {
+    /**
+     * The events that exist for this calendar.
+     */
+    events: Event[];
+    /**
+     * Creates a new Calendar instance.
+     *
+     * @param icsContent The content from an ICS file to initialize the calendar with.
+     *
+     * @returns A new Calendar instance.
+     */
+    constructor(icsContent?: string | undefined);
+    /**
+     * Builds the calendar into a string that conforms to ICS format.
+     *
+     * @returns An ICS formatted string that represents the calendar data.
+     */
+    build(): string | null;
+    /**
+     * Parses the ICS data from a line feeder and constructs the calendar
+     * from that data.
+     *
+     * @param feeder The feeder that provides the individual lines.
+     */
+    private parse;
+}
+export {};

package/types/Utility/lava.d.ts

@@ -0,0 +1 @@
+export declare function resolveMergeFields(template: string, mergeFields: Record<string, unknown>): string;

package/types/Utility/linq.d.ts

@@ -0,0 +1,174 @@
+/**
+ * A function that will select a value from the object.
+ */
+declare type ValueSelector<T> = (value: T) => string | number | boolean | null | undefined;
+/**
+ * A function that will perform testing on a value to see if it meets
+ * a certain condition and return true or false.
+ */
+declare type PredicateFn<T> = (value: T, index: number) => boolean;
+/**
+ * A function that will compare two values to see which one should
+ * be ordered first.
+ */
+declare type ValueComparer<T> = (a: T, b: T) => number;
+/**
+ * Provides LINQ style access to an array of elements.
+ */
+export declare class List<T> {
+    /** The elements being tracked by this list. */
+    protected elements: T[];
+    /**
+     * Creates a new list with the given elements.
+     *
+     * @param elements The elements to be made available to LINQ queries.
+     */
+    constructor(elements?: T[]);
+    /**
+     * Creates a new List from the elements without copying to a new array.
+     *
+     * @param elements The elements to initialize the list with.
+     * @returns A new list of elements.
+     */
+    static fromArrayNoCopy<T>(elements: T[]): List<T>;
+    /**
+     * Returns a boolean that determines if the collection contains any elements.
+     *
+     * @returns true if the collection contains any elements; otherwise false.
+     */
+    any(): boolean;
+    /**
+     * Filters the list by the predicate and then returns a boolean that determines
+     * if the filtered collection contains any elements.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns true if the collection contains any elements; otherwise false.
+     */
+    any(predicate: PredicateFn<T>): boolean;
+    /**
+     * Returns the first element from the collection if there are any elements.
+     * Otherwise will throw an exception.
+     *
+     * @returns The first element in the collection.
+     */
+    first(): T;
+    /**
+     * Filters the list by the predicate and then returns the first element
+     * in the collection if any remain. Otherwise throws an exception.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The first element in the collection.
+     */
+    first(predicate: PredicateFn<T>): T;
+    /**
+     * Returns the first element found in the collection or undefined if the
+     * collection contains no elements.
+     *
+     * @returns The first element in the collection or undefined.
+     */
+    firstOrUndefined(): T | undefined;
+    /**
+     * Filters the list by the predicate and then returns the first element
+     * found in the collection. If no elements remain then undefined is
+     * returned instead.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns The first element in the filtered collection or undefined.
+     */
+    firstOrUndefined(predicate: PredicateFn<T>): T | undefined;
+    /**
+     * Returns a single element from the collection if there is a single
+     * element. Otherwise will throw an exception.
+     *
+     * @returns An element.
+     */
+    single(): T;
+    /**
+     * Filters the list by the predicate and then returns the single remaining
+     * element from the collection. If more than one element remains then an
+     * exception will be thrown.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns An element.
+     */
+    single(predicate: PredicateFn<T>): T;
+    /**
+     * Returns a single element from the collection if there is a single
+     * element. If no elements are found then undefined is returned. More
+     * than a single element will throw an exception.
+     *
+     * @returns An element or undefined.
+     */
+    singleOrUndefined(): T | undefined;
+    /**
+     * Filters the list by the predicate and then returns the single element
+     * from the collection if there is only one remaining. If no elements
+     * remain then undefined is returned. More than a single element will throw
+     * an exception.
+     *
+     * @param predicate The predicate to filter the elements by.
+     *
+     * @returns An element or undefined.
+     */
+    singleOrUndefined(predicate: PredicateFn<T>): T | undefined;
+    /**
+     * Orders the elements of the array and returns a new list of items
+     * in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    orderBy(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Orders the elements of the array in descending order and returns a
+     * new list of items in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    orderByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Filters the results and returns a new list containing only the elements
+     * that match the predicate.
+     *
+     * @param predicate The predicate to filter elements with.
+     *
+     * @returns A new collection of elements that match the predicate.
+     */
+    where(predicate: PredicateFn<T>): List<T>;
+    /**
+     * Get the elements of this list as a native array of items.
+     *
+     * @returns An array of items with all filters applied.
+     */
+    toArray(): T[];
+}
+/**
+ * A list of items that has ordering already applied.
+ */
+declare class OrderedList<T> extends List<T> {
+    /** The base comparer to use when ordering. */
+    private baseComparer;
+    constructor(elements: T[], baseComparer: ValueComparer<T>);
+    /**
+     * Orders the elements of the array and returns a new list of items
+     * in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    thenBy(keySelector: ValueSelector<T>): OrderedList<T>;
+    /**
+     * Orders the elements of the array in descending order and returns a
+     * new list of items in that order.
+     *
+     * @param keySelector The selector for the key to be ordered by.
+     * @returns A new ordered list of elements.
+     */
+    thenByDescending(keySelector: ValueSelector<T>): OrderedList<T>;
+}
+export {};

package/types/Utility/listItemBag.d.ts

@@ -0,0 +1,2 @@
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+export declare function asListItemBagOrNull(bagJson: string): ListItemBag | null;

package/types/Utility/mergeField.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Take a given mergeFieldPicker value and format it for Lava
+ *
+ * @param value The merge field to be formatted
+ *
+ * @returns The formatted string in a Promise
+ */
+export declare function formatValue(value: string): Promise<string>;