@rockrms/obsidian-framework 1.16.3-rc.1

package/types/Core/Controls/valueDetailListItemBuilder.d.ts

@@ -0,0 +1,30 @@
+import { ValueDetailListItem } from "@Obsidian/Types/Controls/valueDetailListItem";
+/**
+ * Class that provides some convenience methods to building an array of
+ * ValueDetailListItem objects for use in the valueDetailList control.
+ */
+export declare class ValueDetailListItemBuilder {
+    private values;
+    /**
+     * Add a new field value with a plain text value. The text value will be
+     * escaped so it is safe to use HTML characters.
+     *
+     * @param title The title of the field to be displayed.
+     * @param text The text value to be displayed.
+     */
+    addTextValue(title: string, text: string): void;
+    /**
+     * Add a new field value with a formatted HTML value. The HTML content
+     * will not be escaped so you must ensure it is valid HTML.
+     *
+     * @param title The title of the field to be displayed.
+     * @param html The text value to be displayed.
+     */
+    addHtmlValue(title: string, html: string): void;
+    /**
+     * Builds the values to be displayed.
+     *
+     * @returns An array of ValueDetailListItem objects containing the items to display.
+     */
+    build(): ValueDetailListItem[];
+}

package/types/Core/Core/personPreferences.d.ts

@@ -0,0 +1,92 @@
+import { IPersonPreferenceCollection } from "@Obsidian/Types/Core/personPreferences";
+import { PersonPreferenceValueBag } from "@Obsidian/ViewModels/Core/personPreferenceValueBag";
+/**
+ * The primary class to use when accessing person preferences. This handles
+ * all the logic of last accessed tracking as well as properly saving and
+ * updating preferences values.
+ *
+ * @private This is an internal implementation and should not be used directly
+ * by plugins.
+ */
+export declare class PersonPreferenceCollection implements IPersonPreferenceCollection {
+    /** The entity type key that we have been scoped to. */
+    readonly entityTypeKey?: string;
+    /** The entity key that we have been scoped to. */
+    readonly entityKey?: string;
+    /**
+     * The prefix that will be prepended to any keys passed to us by the
+     * caller.
+     */
+    readonly prefix: string;
+    /**
+     * Will be `true` if this is a completely anonymous page load. In other
+     * words, updates and saves will not be performed.
+     */
+    readonly anonymous: boolean;
+    /**
+     * The preferences and values we know about. Dictionary key is the
+     * prefixed preference key.
+     */
+    preferences: Record<string, PersonPreferenceValueBag>;
+    /**
+     * A list of prefixed preference keys that have had their values updated.
+     */
+    updatedKeys: string[];
+    /**
+     * A list of prefixed preference keys that need to have their last
+     * accessed timestamp updated.
+     */
+    accessedKeys: string[];
+    /**
+     * The timer that has been scheduled for updating the last accessed
+     * timestamps for any keys that were viewed.
+     */
+    updateAccessedTimer?: number;
+    /**
+     * Creates an empty collection that will not be saved to the database.
+     */
+    constructor();
+    /**
+     * Creates a new collection of person preferences. This instance will handle
+     * all the saving and last-accessed tracking logic.
+     *
+     * @param entityTypeKey The entity type key that these preferences are scoped to.
+     * @param entityKey The entity key that these preferences are scoped to.
+     * @param prefix The additional prefix that will be applied. This should not include the standard `block-##-` prefix.
+     * @param anonymous If `true` then this will be considered an anonymous request and no saves will be performed.
+     * @param preferences The preferences to initialize the collection with.
+     */
+    constructor(entityTypeKey: string | undefined, entityKey: string | undefined, prefix: string, anonymous: boolean, preferences: PersonPreferenceValueBag[]);
+    getValue(key: string): string;
+    setValue(key: string, value: string): void;
+    getKeys(): string[];
+    containsKey(key: string): boolean;
+    save(): Promise<void>;
+    withPrefix(prefix: string): IPersonPreferenceCollection;
+    /**
+     * Gets the prefixed key. This is used during updates. It includes any
+     * user defined prefix, but not the standard entity type prefixes.
+     *
+     * @param key The key that should be prefixed with our standard prefix.
+     *
+     * @returns A new key that has been prefixed.
+     */
+    private getPrefixedKey;
+    /**
+     * Performs the actual update by calling the API on the server.
+     *
+     * @param updatedKeys The keys that have been updated.
+     */
+    private saveUpdatedKeys;
+    /**
+     * Updates the last accessed time stamps for all the keys that have been
+     * accessed.
+     */
+    private updateAccessedKeys;
+    /**
+     * Performs the actual API call to note that we accessed some keys.
+     *
+     * @param accessedKeys The keys that have been accessed.
+     */
+    private postAccessedKeys;
+}

package/types/Core/Reporting/comparisonType.d.ts

@@ -0,0 +1,39 @@
+import { FilterMode } from "./filterMode";
+import { ComparisonType } from "@Obsidian/Enums/Reporting/comparisonType";
+/** The comparison types typically used for simple binary comparison. */
+export declare const binaryComparisonTypes: ComparisonType;
+/** The comparison types typically used for string-type values. */
+export declare const stringComparisonTypes: ComparisonType;
+/** The comparison types typically used for multiple choice values. */
+export declare const containsComparisonTypes: ComparisonType;
+/** The comparison types typically used for numeric values. */
+export declare const numericComparisonTypes: ComparisonType;
+/** The comparison types typically used for date values. */
+export declare const dateComparisonTypes: ComparisonType;
+/**
+ * Gets the user friendly name for the comparison type.
+ *
+ * @param type The type of comparison.
+ *
+ * @returns A string containing the name of the comparison.
+ */
+export declare function getComparisonName(type: ComparisonType): string;
+/**
+ * Checks if the standard comparison type component should be visible or not for
+ * the given comparison type options and filter mode.
+ *
+ * @param comparisonType The comparison types available to be selected.
+ * @param filterMode The type of filtering UI to show.
+ *
+ * @returns true if the comparison type component should be visible; otherwise false.
+ */
+export declare function isCompareVisibleForComparisonFilter(comparisonType: ComparisonType, filterMode: FilterMode): boolean;
+/**
+ * Determines if this comparision type specifies one and only one type. This
+ * uses bitwise logic to ensure that only a single bit is set.
+ *
+ * @param comparisionType The comparison type to check.
+ *
+ * @returns true if the comparison type specifies one and only one type.
+ */
+export declare function isSingleComparisonType(comparisionType: ComparisonType): boolean;

package/types/Core/Reporting/comparisonTypeOptions.d.ts

@@ -0,0 +1,14 @@
+import { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+import { ComparisonType } from "@Obsidian/Enums/Reporting/comparisonType";
+/**
+ * The full list of comparison type options that can be used in pickers.
+ */
+export declare const comparisonTypeOptions: ListItemBag[];
+/**
+ * Gets the comparison type options that match the provides comparison type values.
+ *
+ * @param comparisonTypes The comparison type values to include in the list of options.
+ *
+ * @returns A filtered collection of ListItem objects that contain only the comparison types specified.
+ */
+export declare function getFilteredComparisonTypeOptions(...comparisonTypes: ComparisonType[]): ListItemBag[];

package/types/Core/Reporting/filterExpressionType.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The type of filter expressions that can be used when building filtering rules.
+ */
+export declare enum FilterExpressionType {
+    /** Simple expression filter. */
+    Filter = 0,
+    /**
+     * A collection of expressions/conditions that all must match. Expressions
+     * are "and'd" together.
+     */
+    GroupAll = 1,
+    /**
+     * A collection of expressions/conditions where at least one must match.
+     * Expressions are "or'd" together.
+     */
+    GroupAny = 2,
+    /**
+     * A collection of expressions/conditions where all must be false. Expressions
+     * are combined using a logical OR and the group result must be FALSE.
+     */
+    GroupAllFalse = 3,
+    /**
+     * A collection of expressions/conditions where at least one must be false.
+     * Expressions are combined using a logical AND and the group result must
+     * be FALSE.
+     */
+    GroupAnyFalse = 4
+}

package/types/Core/Reporting/filterMode.d.ts

@@ -0,0 +1,7 @@
+/** The type of filter mode to use when choosing which components to display. */
+export declare enum FilterMode {
+    /** A simple filter editor should be used, with a minimal UI. */
+    Simple = 0,
+    /** A more advanced editor should be used that provides all available options. */
+    Advanced = 1
+}

package/types/Core/Utilities/colorPair.d.ts

@@ -0,0 +1,25 @@
+import { RockColor } from "./rockColor";
+/**
+ * Pair of colors representing the foreground and background colors.
+ */
+export declare class ColorPair {
+    /** The foreground color. */
+    foregroundColor: RockColor;
+    /** The background color. */
+    backgroundColor: RockColor;
+    /**
+     * The contrast ratio between the foreground and background colors.
+     */
+    get contrastRatio(): number;
+    /**
+     * Creates a new pair of colors from the given colors.
+     *
+     * @param foregroundColor The foreground color.
+     * @param backgroundColor The background color.
+     */
+    constructor(foregroundColor: RockColor, backgroundColor: RockColor);
+    /**
+     * Flips the foreground and background colors.
+     */
+    flip(): void;
+}

package/types/Core/Utilities/rockColor.d.ts

@@ -0,0 +1,270 @@
+import { ColorPair } from "./colorPair";
+import { ColorScheme } from "@Obsidian/Enums/Core/colorScheme";
+import { ColorRecipe } from "@Obsidian/Enums/Core/colorRecipe";
+/**
+ * Utility class for color manipulation.
+ */
+export declare class RockColor {
+    private readonly rgbInternal;
+    private alphaInternal;
+    private hueInternal;
+    private saturationInternal;
+    private luminosityInternal;
+    private textInternal?;
+    /**
+     * Gets or sets the Alpha level. This will be between 0 and 1.
+     */
+    get alpha(): number;
+    set alpha(value: number);
+    /**
+     * Gets or sets the Red value of the color. This will be between 0 and 255.
+     */
+    get r(): number;
+    set r(value: number);
+    /**
+     * Gets or sets the Green value of the color. This will be between 0 and 255.
+     */
+    get g(): number;
+    set g(value: number);
+    /**
+     * Gets or sets the Blue value of the color. This will be between 0 and 255.
+     */
+    get b(): number;
+    set b(value: number);
+    /**
+     * Calculates the luma value based on the W3 Standard.
+     */
+    get luma(): number;
+    /**
+     * Gets or sets the hue of the color.
+     */
+    get hue(): number;
+    set hue(value: number);
+    /**
+     * Gets or sets the saturation of the color.
+     */
+    get saturation(): number;
+    set saturation(value: number);
+    /**
+     * Gets or sets the luminosity of the color.
+     */
+    get luminosity(): number;
+    set luminosity(value: number);
+    /**
+     * Gets the color as a hexadecimal string, including the leading `#`.
+     */
+    get hex(): string;
+    /**
+     * Determines if the color is a light color.
+     */
+    get isLight(): boolean;
+    /**
+     * Determines if the color is a dark color.
+     */
+    get isDark(): boolean;
+    constructor(color: string);
+    constructor(rgb: number[]);
+    constructor(rgb: number[], alpha: number);
+    constructor(rgb: number[], alpha: number, text: string);
+    constructor(color: number);
+    constructor(red: number, green: number, blue: number);
+    constructor(red: number, green: number, blue: number, alpha: number);
+    constructor(red: number, green: number, blue: number, alpha?: number, text?: string);
+    /**
+     * Creates this instance from the specified number value. This is a numeric
+     * representation such as 0x112233.
+     *
+     * @param color The color has a number value.
+     */
+    private constructFromSingleNumber;
+    /**
+     * Creates this instance from the specified text value. This can be either
+     * a `#` hex value, an `rgba` value, an `rgb` value or a named HTML color.
+     *
+     * @param color The string that represents the color.
+     */
+    private constructFromString;
+    /**
+     * Creates this instance from the specified RGB and alpha values.
+     *
+     * @param rgb The RGB components, this must always have 3 components.
+     * @param alpha The alpha value to assign.
+     */
+    private constructFromRgb;
+    /**
+     * Updates the HSL values of the color from the RGB values.
+     */
+    private updateHslFromRgb;
+    /**
+     * Updates the RGB values of the color from the HSL values.
+     */
+    private updateRgbFromHsl;
+    /**
+     * Gets the {@link RockColor} that corresponds to the HTML color keyword.
+     *
+     * @param keyword The HTML color keyword.
+     *
+     * @returns An instance of {@link RockColor} that represents the color or `null` if not found.
+     */
+    static getColorFromKeyword(keyword: string): RockColor | null;
+    /**
+     * Calculates the contrast ratio between two colors.
+     *
+     * @param color1 The first color.
+     * @param color2 The second color.
+     *
+     * @returns A number that represents the contrast ratio between the two colors.
+     */
+    static calculateContrastRatio(color1: RockColor, color2: RockColor): number;
+    /**
+     * Creates a color pair from a single color with logic for light and
+     * dark modes.
+     *
+     * @param color The base color to use when creating the color pair.
+     * @param colorScheme The color scheme the color will be used in.
+     *
+     * @returns A new instance of {@link ColorPair}.
+     */
+    static calculateColorPair(color: RockColor, colorScheme?: ColorScheme): ColorPair;
+    /**
+     * Creates a recipe color from the provided color.
+     *
+     * @param color The base color to calculate the new color from.
+     * @param recipe The recipe to use when calculating the new color.
+     *
+     * @returns A new instance of {@link RockColor}.
+     */
+    static calculateColorRecipe(color: RockColor, recipe: ColorRecipe): RockColor;
+    /**
+     * Lightens the color by the provided percentage.
+     *
+     * @param percentage The percentage amount to lighten the color as a number between 0 and 100.
+     */
+    lighten(percentage: number): void;
+    /**
+     * Darkens the color by the provided percentage.
+     *
+     * @param percentage The percentage amount to darken the color as a number between 0 and 100.
+     */
+    darken(percentage: number): void;
+    /**
+     * Saturates the color by the provided percentage.
+     *
+     * @param percentage The percentage amount to saturate the color as a number between 0 and 100.
+     */
+    saturate(percentage: number): void;
+    /**
+     * Desaturates the color by the provided percentage.
+     *
+     * @param percentage The percentage amount to desaturate the color as a number between 0 and 100.
+     */
+    desaturate(percentage: number): void;
+    /**
+     * Increases the opacity level by the given percentage. This makes the
+     * color less transparent and more opaque.
+     *
+     * @param percentage The percentage amount to adjust the alpha as a number between 0 and 100.
+     */
+    fadeIn(percentage: number): void;
+    /**
+     * Decreases the opacity level by the given percentage. This makes the
+     * color more transparent and less opaque.
+     *
+     * @param percentage The percentage amount to adjust the alpha as a number between 0 and 100.
+     */
+    fadeOut(percentage: number): void;
+    /**
+     * Adjusts the hue by the specified percentage.
+     *
+     * @param percentage The percentage to adjust the hue by as a value between -100 and 100.
+     */
+    adjustHueByPercent(percentage: number): void;
+    /**
+     * Adjusts the hue by the specified number of degrees.
+     *
+     * @param degrees The number of degrees to adjust the hue by as a value between -360 and 360.
+     */
+    adjustHueByDegrees(degrees: number): void;
+    /**
+     * Tints the specified percentage amount. This mixes this color with white
+     * by the percentage.
+     *
+     * @param percentage The percentage amount as a value between 0 and 100.
+     */
+    tint(percentage: number): void;
+    /**
+     * Shades the specified percentage amount. This mixes this color with black
+     * by the percentage.
+     *
+     * @param percentage The percentage amount as a value between 0 and 100.
+     */
+    shade(percentage: number): void;
+    /**
+     * Mixes the specified color into the current color with an optional
+     * percentage amount.
+     *
+     * @param mixColor The color to be mixed into this color.
+     * @param percentage The percentage amount to be mixed as a value between 0 and 100. Defaults to 50.
+     */
+    mix(mixColor: RockColor, percentage?: number): void;
+    /**
+     * Turns the color to it's grayscale value.
+     */
+    grayscale(): void;
+    /**
+     * Creates a clone of this color.
+     *
+     * @returns A new instance that has the same color values as this instance.
+     */
+    clone(): RockColor;
+    /**
+     * Converts the current color to a CSS `rgba` string format.
+     *
+     * @returns A string representation of the color.
+     */
+    toRgba(): string;
+    /**
+     * Converts the current color to an HTML hexadecimal `#rrggbbaa` string
+     * format. If the alpha value is 1 then the "aa" component will not be
+     * included.
+     *
+     * @returns Hexadecimal version of the color.
+     */
+    toHex(): string;
+    /**
+     * Gets a numeric value representing this color. If two colors have the
+     * same RGB and Alpha values then they will return the same value here.
+     *
+     * @returns A numeric value that represents this unique color.
+     */
+    valueOf(): number;
+    /**
+     * Compares this color against another color to see which one has a higher
+     * value.
+     *
+     * @param otherColor The other color to compare this color to.
+     *
+     * @returns `0` if both colors are the same, `-1` if this color is less than the other color and `1` if this color is greater than the other color.
+     */
+    compareTo(otherColor: RockColor | undefined | null): number;
+    /**
+     * Determines if two colors are similar.
+     *
+     * @param otherColor The other color to compare this color to.
+     * @param similarityPercent The minimum percentage to consider the colors similar. This will be between 0 and 1 (defaults to 0.95).
+     * @returns `true` if the colors are N percent similar, where N is the `similarityPercentage`; otherwise, returns `false`.
+     * @example
+     * // this = new RockColor("#FFF")
+     * this.isSimilarTo(new RockColor("#FFE"), 0.95) // `true`, color similarity >= 95%
+     * this.isSimilarTo(new RockColor("#FFE"), 0.99) // `false`, color similarity < 99%
+     * this.isSimilarTo(new RockColor("#FFE"), 1) // `false`, color similarity != 100%
+     * this.isSimilarTo(new RockColor("#FFF"), 1) // `true`, color similarity = 100%
+     */
+    isSimilarTo(otherColor: RockColor, similarityPercent?: number): boolean;
+    /**
+     * Gets the sRGB value of this color.
+     *
+     * @returns This color in the standard RGB color space.
+     */
+    private toStandardRgb;
+}

package/types/Directives/dragDrop.d.ts

@@ -0,0 +1,130 @@
+import { Directive, Ref } from "vue";
+/**
+ * The options that can be used when defining a drag source for a drag and
+ * drop operation.
+ */
+export interface IDragSourceOptions {
+    /**
+     * The unique identifier for this drag drop connection. This should match
+     * the id used for drag targets.
+     */
+    id: string;
+    /**
+     * Defines the query selector that specifies which elements may act as drag
+     * handles. By default all elements are allowed. This value will be ignored
+     * if you defined a value for canStartDrag.
+     */
+    handleSelector?: string;
+    /**
+     * Defines the container element that dragged mirror elements will be added
+     * to. If not set then the body element is used. This property is dynamic and
+     * can be updated on the fly. It will be used anytime a drag operation is
+     * about to begin.
+     */
+    mirrorContainer?: Element;
+    /**
+     * true if elements are duplicated and instead of the original being moved.
+     */
+    copyElement?: boolean | ((operation: DragOperation) => boolean);
+    /**
+     * Function that returns true if the element can start dragging.
+     */
+    startDrag?: (operation: DragOperation, handle: Element) => boolean;
+    /**
+     * Function that returns true if the element being dragged can be dropped
+     * on the target.
+     */
+    acceptDrop?: (operation: DragOperation) => boolean;
+    /**
+     * Called when a drag operation has successfully started.
+     */
+    dragBegin?: (operation: DragOperation) => void;
+    /**
+     * Called when a drag operation has ended for any reason.
+     */
+    dragEnd?: (operation: DragOperation) => void;
+    /**
+     * Called when a drag operation has successfully completed.
+     */
+    dragDrop?: (operation: DragOperation) => void;
+    /**
+     * Called when the drag operation was cancelled, usually because it was dropped
+     * outside of a valid container.
+     */
+    dragCancel?: (operation: DragOperation) => void;
+    /**
+     * Called when a drag operation has moved over the specified valid target
+     * container.
+     */
+    dragOver?: (operation: DragOperation) => void;
+    /**
+     * Called when a drag operation has moved out of the specified container (or
+     * was dropped into it).
+     */
+    dragOut?: (operation: DragOperation) => void;
+    /**
+     * Called when a drag operation has created, or positioned, the shadow element
+     * that is being displayed in the target container.
+     */
+    dragShadow?: (operation: DragOperation) => void;
+}
+/**
+ * The options that can be used when defining a drag target for a drag and
+ * drop operation.
+ */
+export interface IDragTargetOptions {
+    id: string;
+}
+/**
+ * Details about a drag operation that is in progress.
+ */
+export declare type DragOperation = {
+    /** The element that is being dragged. */
+    element: Element;
+    /** The shadow element that is currently displayed in the target container. */
+    shadow?: Element;
+    /** The container that the element is originally from. */
+    sourceContainer: Element;
+    /** The index position in the sourceContainer for the element. */
+    sourceIndex: number;
+    /** The next sibling after the element before the drag operation started. */
+    sourceSibling?: Element;
+    /** The target container the element is hovering over or being dropped into. */
+    targetContainer?: Element;
+    /** The index position in the targetContainer. */
+    targetIndex?: number;
+    /** The next sibling the element is hovering or being dropped before. */
+    targetSibling?: Element;
+};
+/**
+ * Defines the source of a drag and drop operation.
+ *
+ * When using a v-for to display the items, ensure you use a unique :key. Otherwise
+ * when you .splice() after a drop weird things will happen.
+ */
+export declare const DragSource: Directive<HTMLElement, IDragSourceOptions>;
+/**
+ * Defines the target of a drag and drop operation.
+ *
+ * When using a v-for to display the items, ensure you use a unique :key. Otherwise
+ * when you .splice() after a drop weird things will happen.
+ */
+export declare const DragTarget: Directive<HTMLElement, string | IDragTargetOptions>;
+/**
+ * Defines the source and target of a drag and drop reorder operation.
+ *
+ * When using a v-for to display the items, ensure you use a unique :key. Otherwise
+ * when you .splice() after a drop weird things will happen.
+ */
+export declare const DragReorder: Directive<HTMLElement, IDragSourceOptions>;
+/**
+ * Get the drag source options for re-ordering the sections. This allows the user
+ * to drag and drop existing sections to move them around the form. The contents
+ * of the array are modified to match the new order.
+ *
+ * @param values The values that can be reordered.
+ * @param reorder The function to call when items have been reordered.
+ *
+ * @returns The IDragSourceOptions object to use for the DragReorder directive.
+ */
+export declare function useDragReorder<T>(values: Ref<T[] | undefined | null>, reorder?: ((value: T, beforeValue: T | null) => void | Promise<void> | boolean | Promise<boolean>)): IDragSourceOptions;

package/types/Directives/dragScroll.d.ts

@@ -0,0 +1,28 @@
+import { Directive } from "vue";
+/**
+ * The options that can be used when defining a drag scroll instance.
+ */
+export interface IDragScrollOptions {
+    /** The unique identifier for this drag scroll instance. Recommended to be a Guid. */
+    id: string;
+}
+/**
+ * A directive to enable "drag-scroll" behavior for the host element.
+ *
+ * If the host element itself is not scrollable in the X or Y direction, its ancestors will be searched
+ * to find the first one that is scrollable in each direction.
+ *
+ * The following [mouse button] modifiers may be used:
+ *  "left"
+ *  "middle"
+ *  "right"
+ */
+export declare const DragScroll: Directive<HTMLElement, IDragScrollOptions>;
+/**
+ * A directive to disable "drag-scroll" behavior for the host element and its descendants.
+ *
+ * Use this directive on any descendants of an element that has the `DragScroll` directive applied,
+ * in order to opt-out of the "drag-scroll" behavior if this element (or any of its descendants)
+ * are the target of the `MouseEvent`.
+ */
+export declare const NoDragScroll: Directive<HTMLElement>;

package/types/Enums/AI/chatMessageRole.d.ts

@@ -0,0 +1,13 @@
+/** The role of the message for a chat completion. */
+export declare const ChatMessageRole: {
+    /** Represents the message sent by the user, which usually includes questions, statements, or conversation prompts. */
+    readonly User: 0;
+    /** Represents a system instruction or directive, usually setting the context or providing guidelines for the AI's behavior in the conversation. */
+    readonly System: 1;
+    /** Represents the response generated by the AI model, in reply to the user's message or following the system instructions. */
+    readonly Assistant: 2;
+};
+/** The role of the message for a chat completion. */
+export declare const ChatMessageRoleDescription: Record<number, string>;
+/** The role of the message for a chat completion. */
+export declare type ChatMessageRole = typeof ChatMessageRole[keyof typeof ChatMessageRole];