@transcommerce/cwm-shared 1.1.87 → 1.1.90

package/lib/helpers/utilities.d.ts

@@ -1,5 +1,25 @@
 import { HttpResponse, HttpResponseBase } from '@angular/common/http';
 import * as i0 from "@angular/core";
+/**
+ * A comprehensive utility service providing static helper methods for common operations across the application.
+ *
+ * This service includes utilities for:
+ * - **Cookie Management**: Getting, setting, removing, and checking cookies with proper encoding
+ * - **Security**: Scrubbing sensitive data from logs to prevent accidental exposure of PII and credentials
+ * - **HTTP Response Handling**: Parsing and extracting meaningful messages from HTTP responses and errors
+ * - **Date/Time Formatting**: Converting dates to various human-readable formats and calculating durations
+ * - **String Manipulation**: Case conversion, text expansion, trimming, and parsing operations
+ * - **Data Processing**: Array operations, deep cloning, searching, and JSON parsing with fallback handling
+ * - **Validation**: Type checking, URL validation, and network connectivity checks
+ *
+ * @example
+ * // Using static utility methods
+ * const scrubbedLog = Utilities.scrubForLog(sensitiveData);
+ * const formattedDate = Utilities.printFriendlyDate(new Date());
+ * const errorMessage = Utilities.getHttpResponseMessage(httpError);
+ *
+ * @injectable
+ */
 export declare class Utilities {
     static readonly captionAndMessageSeparator = ":";
     static readonly noNetworkMessageCaption = "No Network";
@@ -8,11 +28,53 @@ export declare class Utilities {
     static readonly accessDeniedMessageDetail = "";
     static readonly notFoundMessageCaption = "Not Found";
     static readonly notFoundMessageDetail = "The target resource cannot be found";
+    /**
+     * Cookie management utilities providing cross-browser compatible methods for cookie operations.
+     * All cookie keys and values are properly URL-encoded/decoded to handle special characters safely.
+     *
+     * Methods:
+     * - getItem: Retrieves a cookie value by name, returns null if not found
+     * - setItem: Sets a cookie with optional expiration, path, domain, and secure flags
+     * - removeItem: Removes a cookie by setting its expiration to the past
+     * - hasItem: Checks if a cookie exists
+     * - keys: Returns an array of all cookie names
+     */
     static cookies: {
+        /**
+         * Retrieves the value of a cookie by its name with proper URL decoding.
+         * @param sKey The cookie name to retrieve
+         * @returns The decoded cookie value or null if not found
+         */
         getItem: (sKey: string) => string | null;
+        /**
+         * Sets a cookie with optional expiration, domain, path, and secure flag.
+         * @param sKey The cookie name
+         * @param sValue The cookie value
+         * @param vEnd The expiration (Number for max-age in seconds, String for expires date, Date object, or null for session cookie)
+         * @param sPath The path scope for the cookie (defaults to all paths if empty)
+         * @param sDomain The domain scope for the cookie (defaults to current domain if empty)
+         * @param bSecure Whether to set the Secure flag (cookie only sent over HTTPS)
+         * @returns true if the cookie was set successfully, false otherwise
+         */
         setItem: (sKey: string, sValue: string, vEnd: any, sPath: string, sDomain: string, bSecure: unknown) => boolean;
+        /**
+         * Removes a cookie by setting its expiration to a past date.
+         * @param sKey The cookie name to remove
+         * @param sPath The path scope (must match the path used when setting the cookie)
+         * @param sDomain The domain scope (must match the domain used when setting the cookie)
+         * @returns true if the removal was attempted, false if key was invalid
+         */
         removeItem: (sKey: string | number | boolean, sPath: string, sDomain: string) => boolean;
+        /**
+         * Checks if a cookie with the specified name exists.
+         * @param sKey The cookie name to check
+         * @returns true if the cookie exists, false otherwise
+         */
         hasItem: (sKey: string | number | boolean) => boolean;
+        /**
+         * Retrieves all cookie names as an array.
+         * @returns An array of all cookie names with proper URL decoding applied
+         */
         keys: () => string[];
     };
     /** Scrubs sensitive information from logs, such as email addresses, JWTs, tokens, GUIDs, credit card numbers, SSNs, phone numbers, and common password/username patterns.
@@ -30,49 +92,288 @@ export declare class Utilities {
      * console.log(scrubbedData);
      */
     static scrubForLog(input: any): string;
+    /**
+     * Extracts all messages from an HTTP response or error, formatting them as key-value pairs.
+     * Automatically detects network errors, access denied, and not found responses with special formatting.
+     *
+     * @param data The HTTP response or error object
+     * @returns An array of formatted message strings in the format "Key: Value"
+     */
     static getHttpResponseMessages(data: HttpResponseBase): string[];
+    /**
+     * Extracts a single consolidated message from an HTTP response or error.
+     * Searches in priority order: network message, not found message, error_description, error, then general response messages.
+     *
+     * @param data The HTTP response or error object
+     * @returns A single formatted message string
+     */
     static getHttpResponseMessage(data: HttpResponseBase | any): string;
+    /**
+     * Searches for a specific message within HTTP response messages.
+     * Can search in caption only or in full message text, and can optionally include the caption in the result.
+     *
+     * @param messageToFind The message or caption text to search for (case-insensitive)
+     * @param data The HTTP response or error object
+     * @param searchInCaptionOnly If true, only searches in the caption portion (before separator), defaults to true
+     * @param includeCaptionInResult If true, includes the caption in the returned result, defaults to false
+     * @returns The matching message or null if not found
+     */
     static findHttpResponseMessage(messageToFind: string, data: HttpResponse<any> | any, searchInCaptionOnly?: boolean, includeCaptionInResult?: boolean): any;
+    /**
+     * Extracts the response body from an HTTP response or error.
+     * For successful responses, returns the body property. For error responses, prioritizes error over message and statusText.
+     *
+     * @param response The HTTP response or error response
+     * @returns The response body, error, or null if none available
+     */
     static getResponseBody(response: HttpResponseBase): any;
+    /**
+     * Checks if the response indicates a network error (status 0).
+     * @param response The HTTP response to check
+     * @returns true if status is 0 (no network connection), false otherwise
+     */
     static checkNoNetwork(response: HttpResponseBase): boolean;
+    /**
+     * Checks if the response indicates an access denied error (status 403).
+     * @param response The HTTP response to check
+     * @returns true if status is 403 (Forbidden), false otherwise
+     */
     static checkAccessDenied(response: HttpResponseBase): boolean;
+    /**
+     * Checks if the response indicates a not found error (status 404).
+     * @param response The HTTP response to check
+     * @returns true if status is 404 (Not Found), false otherwise
+     */
     static checkNotFound(response: HttpResponseBase): boolean;
+    /**
+     * Validates if a URL points to localhost or 127.0.0.1.
+     * @param url The URL to check
+     * @param base Optional base URL for resolving relative URLs
+     * @returns true if the URL hostname is localhost or 127.0.0.1, false otherwise
+     */
     static checkIsLocalHost(url: string, base?: string): boolean;
+    /**
+     * Parses a query parameter string into a key-value object.
+     * Handles standard URL query string format (key=value&key=value).
+     *
+     * @param paramString The query parameter string (e.g., "id=123&name=test")
+     * @returns An object with key-value pairs, or null if paramString is empty
+     */
     static getQueryParamsFromString(paramString: string): {
         [key: string]: string;
     } | null;
+    /**
+     * Splits a string into two parts based on the first occurrence of a separator.
+     * Both parts are trimmed of whitespace.
+     *
+     * @param text The text to split
+     * @param separator The separator string to split on
+     * @returns An object with firstPart and secondPart (secondPart is null if separator not found)
+     */
     static splitInTwo(text: string, separator: string): {
         firstPart: string;
         secondPart: any;
     };
+    /**
+     * Safely stringifies an object, filtering out complex types and handling circular references.
+     * If direct JSON.stringify fails, creates a sanitized object containing only primitive properties.
+     *
+     * @param object The object to stringify
+     * @returns A JSON string representation of the object, or a sanitized version if stringification fails
+     */
     static safeStringify(object: {
         [x: string]: any;
         hasOwnProperty: (arg0: string) => any;
     }): string;
+    /**
+     * Safely parses a JSON string with fallback handling.
+     * Returns the parsed object if valid JSON, or returns undefined/value if parsing fails.
+     *
+     * @param value The JSON string to parse
+     * @returns The parsed object, 'undefined' if the string is 'undefined', or the original value if parsing fails
+     */
     static JsonTryParse(value: string): any;
+    /**
+     * Checks if an object has no properties.
+     * @param obj The object to check
+     * @returns true if the object is empty (no own properties), false otherwise
+     */
     static TestIsObjectEmpty(obj: any): boolean;
+    /**
+     * Checks if a value is undefined.
+     * @param value The value to check
+     * @returns true if the value is undefined, false otherwise
+     */
     static TestIsUndefined(value: any): value is undefined;
+    /**
+     * Checks if a value is a string.
+     * @param value The value to check
+     * @returns true if the value is a string primitive or String object, false otherwise
+     */
     static TestIsString(value: any): value is string | String;
+    /**
+     * Capitalizes the first letter of a string while leaving the rest unchanged.
+     * @param text The text to capitalize
+     * @returns The text with the first character uppercased, or the original text if empty
+     */
     static capitalizeFirstLetter(text: string): string;
+    /**
+     * Converts a string to title case, capitalizing the first letter of each word.
+     * @param text The text to convert to title case
+     * @returns The text in title case format
+     */
     static toTitleCase(text: string): string;
+    /**
+     * Converts a string or array of strings to lowercase.
+     * Supports overloaded signatures for both single string and array inputs.
+     *
+     * @param items A string or array of strings to convert to lowercase
+     * @returns The lowercased string or array of lowercased strings
+     */
     static toLowerCase(items: string): any;
     static toLowerCase(items: string[]): any;
+    /**
+     * Generates a unique random ID string.
+     * @returns A string representation of a random number between 1,000,000 and 9,000,000
+     */
     static uniqueId(): string;
+    /**
+     * Generates a random integer within a specified range (inclusive).
+     * @param min The minimum value (inclusive)
+     * @param max The maximum value (inclusive)
+     * @returns A random integer between min and max
+     */
     static randomNumber(min: number, max: number): number;
+    /**
+     * Gets the base URL of the current application.
+     * Handles cases where window.location.origin is not available by constructing it from components.
+     *
+     * @returns The base URL without trailing slash (e.g., "http://localhost:4200")
+     */
     static baseUrl(): string;
+    /**
+     * Formats a date to display only the date portion in human-readable format.
+     * Example output: "Monday, 1st January 2024"
+     *
+     * @param date The date to format
+     * @returns A formatted date string with day of week, day of month with ordinal suffix, month name, and year
+     */
     static printDateOnly(date: Date): string;
+    /**
+     * Formats a date to display only the time portion in 12-hour format with AM/PM.
+     * Example output: "2:30 PM"
+     *
+     * @param date The date to format
+     * @returns A formatted time string in HH:MM AM/PM format
+     */
     static printTimeOnly(date: Date): string;
+    /**
+     * Combines date and time formatting into a single readable string.
+     * Example output: "Monday, 1st January 2024 at 2:30 PM"
+     *
+     * @param date The date to format
+     * @param separator The text to insert between date and time (defaults to 'at')
+     * @returns A combined date and time string
+     */
     static printDate(date: Date, separator?: string): string;
+    /**
+     * Formats a date using friendly relative terminology for recent dates.
+     * Returns "Today", "Yesterday", or full date for older dates.
+     *
+     * @param date The date to format
+     * @param separator The text to insert between "Today"/"Yesterday" and time (defaults to '-')
+     * @returns A friendly date string (e.g., "Today - 2:30 PM" or full date for older dates)
+     */
     static printFriendlyDate(date: Date, separator?: string): string;
+    /**
+     * Formats a date to a short format with time.
+     * Example output: "03/01/2024 - 2:30 PM"
+     *
+     * @param date The date to format
+     * @param separator The separator between month, day, and year (defaults to '/')
+     * @param dateTimeSeparator The separator between date and time (defaults to '-')
+     * @returns A formatted short date string with time
+     */
     static printShortDate(date: Date, separator?: string, dateTimeSeparator?: string): string;
+    /**
+     * Parses various date formats into a Date object.
+     * Supports Date objects, ISO strings, and timestamps (milliseconds).
+     * Automatically appends 'Z' to date strings without timezone information.
+     *
+     * @param date The date in various formats (Date, string, or number/timestamp)
+     * @returns A Date object, or an empty string if input is null/undefined
+     */
     static parseDate(date: any): "" | Date;
+    /**
+     * Calculates and formats the duration between two dates.
+     * Breaks down the duration into days, hours, minutes, and seconds.
+     * Example output: "2 days, 3 hours, 15 minutes and 30 seconds"
+     *
+     * @param start The start date
+     * @param end The end date
+     * @returns A human-readable duration string
+     */
     static printDuration(start: Date, end: Date): string;
+    /**
+     * Calculates the age in years between two dates.
+     * Properly accounts for whether the birthday has occurred in the current year.
+     *
+     * @param birthDate The birth date (can be string, number timestamp, or Date object)
+     * @param otherDate The reference date to calculate age from (can be string, number timestamp, or Date object)
+     * @returns The age in years as an integer
+     */
     static getAge(birthDate: string | number | Date, otherDate: string | number | Date): number;
+    /**
+     * Performs a deep clone of an array, recursively copying nested arrays and objects.
+     * Primitive types are returned unchanged, and handles circular references safely.
+     *
+     * @param items The array to clone
+     * @returns A deep copy of the array with all nested structures cloned
+     */
     static deepCloneArray<T>(items: T[]): T[];
+    /**
+     * Searches for a term within an array of values using case-sensitive or case-insensitive matching.
+     * Joins all values into a single string and searches for the term within it.
+     *
+     * @param searchTerm The term to search for
+     * @param caseSensitive Whether the search should be case-sensitive (defaults to false)
+     * @param values Variable number of values to search within
+     * @returns true if the search term is found, false otherwise
+     */
     static searchArray(searchTerm: string, caseSensitive: boolean, ...values: any[]): boolean;
+    /**
+     * Moves an item within an array from one index to another.
+     * Handles negative indices (counts from the end) and automatically extends the array if needed.
+     *
+     * @param array The array to modify
+     * @param oldIndex The current index of the item to move
+     * @param newIndex The target index to move the item to
+     */
     static moveArrayItem(array: any[], oldIndex: number, newIndex: number): void;
+    /**
+     * Expands camelCase text into space-separated words.
+     * Handles both camelCase and PascalCase patterns as well as non-alphanumeric characters.
+     * Example: "myPropertyName" becomes "my Property Name"
+     *
+     * @param text The camelCase text to expand
+     * @returns The expanded text with spaces between words
+     */
     static expandCamelCase(text: string): string;
+    /**
+     * Tests whether a URL is absolute (starts with protocol or //).
+     * Matches URLs like "http://example.com" or "//example.com"
+     *
+     * @param url The URL to test
+     * @returns true if the URL is absolute, false if it's relative
+     */
     static testIsAbsoluteUrl(url: string): boolean;
+    /**
+     * Converts a relative URL to an absolute URL by prepending //.
+     * If the URL is already absolute, it's returned unchanged.
+     *
+     * @param url The URL to convert
+     * @returns The absolute URL (e.g., "//example.com" for "example.com")
+     */
     static convertToAbsoluteUrl(url: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<Utilities, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<Utilities>;

package/lib/models/slide.d.ts

@@ -1,3 +1,6 @@
+import { ImageStyle } from './style/image-style';
+import { ColorStyle } from './style/color-style';
+import { TextStyle } from './style/text-style';
 export type Slide = {
     image: string;
     title: string;
@@ -6,7 +9,15 @@ export type Slide = {
     textColor: 'red' | 'green' | 'blue' | 'yellow' | 'black' | 'white';
     backgroundColor: 'red' | 'green' | 'blue' | 'yellow' | 'black' | 'white';
 };
+export declare class FooterSlide {
+    image: ImageStyle;
+    title: TextStyle;
+    description: TextStyle;
+    highlighted: boolean;
+    backgroundColor: ColorStyle;
+}
 export declare const DEFAULT_SLIDE: Slide;
+export declare const DEFAULT_FOOTER_SLIDE: FooterSlide;
 export declare const SLIDE_SCHEMA: {
     type: string;
     title: string;
@@ -52,3 +63,35 @@ export declare const SLIDE_SCHEMA: {
     };
     required: string[];
 };
+export declare const FOOTER_SLIDE_SCHEMA: {
+    type: string;
+    title: string;
+    properties: {
+        image: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        title: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        description: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        highlighted: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        backgroundColor: {
+            type: string;
+            title: string;
+            description: string;
+        };
+    };
+    required: string[];
+};

package/lib/models/style/color-style.d.ts

@@ -2,7 +2,7 @@ import { NamedColors } from './named-colors';
 import { RgbaColorStyle } from './rgba-color-style';
 import { HexColor } from './hex-color';
 import { OnStyle } from './on-style';
-import { ngStyleItem } from './ng-style-item';
+import { ngStyleAttribute } from './ng-style-attribute';
 export type ColorValue = NamedColors | HexColor | RgbaColorStyle;
 /**
  * A unified Color class that can represent colors as Named, Hex, or RGBA formats
@@ -11,7 +11,7 @@ export type ColorValue = NamedColors | HexColor | RgbaColorStyle;
 export declare class ColorStyle implements OnStyle {
     private _value;
     constructor(value: ColorValue);
-    ngOnStyle(ngStyle: ngStyleItem): ngStyleItem;
+    ngOnStyle(ngStyle: ngStyleAttribute): ngStyleAttribute;
     /**
      * Gets the original color value
      */

package/lib/models/style/coordinates-style.d.ts

@@ -1,8 +1,27 @@
 import { OnStyle } from './on-style';
-import { ngStyleItem } from './ng-style-item';
+import { ngStyleAttribute } from './ng-style-attribute';
 export declare class CoordinatesStyle implements OnStyle {
     top: number | string | any | undefined;
     left: number | string | any | undefined;
-    ngOnStyle(ngStyle: ngStyleItem): ngStyleItem;
+    ngOnStyle(ngStyle: ngStyleAttribute): ngStyleAttribute;
 }
 export declare const DEFAULT_COORDINATES: CoordinatesStyle;
+export declare const COORDINATES_STYLE_SCHEMA: {
+    type: string;
+    title: string;
+    properties: {
+        top: {
+            type: string;
+            title: string;
+            description: string;
+            default: number;
+        };
+        left: {
+            type: string;
+            title: string;
+            description: string;
+            default: number;
+        };
+    };
+    required: string[];
+};

package/lib/models/style/font-style.d.ts

@@ -1,11 +1,48 @@
 import { OnStyle } from './on-style';
-import { ngStyleItem } from './ng-style-item';
+import { ngStyleAttribute } from './ng-style-attribute';
 export declare class FontStyle implements OnStyle {
     family: string;
     size: number;
     italic: boolean;
     bold: boolean;
     underline: boolean;
-    ngOnStyle(ngStyle: ngStyleItem): ngStyleItem;
+    ngOnStyle(ngStyle: ngStyleAttribute): ngStyleAttribute;
 }
 export declare const DEFAULT_FONT: FontStyle;
+export declare const FONT_STYLE_SCHEMA: {
+    type: string;
+    title: string;
+    properties: {
+        family: {
+            type: string;
+            title: string;
+            description: string;
+            default: string;
+        };
+        size: {
+            type: string;
+            title: string;
+            description: string;
+            default: number;
+        };
+        italic: {
+            type: string;
+            title: string;
+            description: string;
+            default: boolean;
+        };
+        bold: {
+            type: string;
+            title: string;
+            description: string;
+            default: boolean;
+        };
+        underline: {
+            type: string;
+            title: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    required: string[];
+};

package/lib/models/style/hex-color.d.ts

@@ -120,3 +120,11 @@ export declare function hexToNamedColor(hexColor: HexColor): string | null;
  * @returns Named color string or null if no close match found
  */
 export declare function rgbaToNamedColor(rgba: RgbaColorStyle): string | null;
+export declare const DEFAULT_HEX_COLOR: HexColor;
+export declare const HEX_COLOR_SCHEMA: {
+    type: string;
+    title: string;
+    description: string;
+    pattern: string;
+    default: `#${string}`;
+};

package/lib/models/style/image-style.d.ts

@@ -2,12 +2,66 @@ import { CoordinatesStyle } from './coordinates-style';
 import { Justifications } from './justifications';
 import { SizeStyle } from "./size-style";
 import { OnStyle } from './on-style';
-import { ngStyleItem } from './ng-style-item';
+import { ngStyleAttribute } from './ng-style-attribute';
 export declare class ImageStyle implements OnStyle {
     href: string | URL;
     justification: Justifications;
     size: SizeStyle | undefined;
     coordinates: CoordinatesStyle | undefined;
-    ngOnStyle(ngStyle: ngStyleItem): ngStyleItem;
+    ngOnStyle(ngStyle: ngStyleAttribute): ngStyleAttribute;
 }
-export declare const DEFAULT_IMAGE: ImageStyle;
+export declare const DEFAULT_IMAGE_STYLE: ImageStyle;
+export declare const IMAGE_STYLE_SCHEMA: {
+    type: string;
+    title: string;
+    properties: {
+        href: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        justification: {
+            enum: Justifications[];
+            type: string;
+            title: string;
+            description: string;
+        };
+        size: {
+            type: string;
+            title: string;
+            description: string;
+            properties: {
+                width: {
+                    type: string[];
+                    title: string;
+                    description: string;
+                };
+                height: {
+                    type: string[];
+                    title: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+        coordinates: {
+            type: string;
+            title: string;
+            description: string;
+            properties: {
+                top: {
+                    type: string[];
+                    title: string;
+                    description: string;
+                };
+                left: {
+                    type: string[];
+                    title: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    required: string[];
+};

package/lib/models/style/justifications.d.ts

@@ -4,3 +4,11 @@ export declare enum Justifications {
     Center = "center",
     Fully = "fully"
 }
+export declare const DEFAULT_JUSTIFICATION = Justifications.Left;
+export declare const JUSTIFICATIONS_SCHEMA: {
+    type: string;
+    title: string;
+    description: string;
+    enum: Justifications[];
+    default: Justifications;
+};

package/lib/models/style/named-colors.d.ts

@@ -170,3 +170,11 @@ export declare function isNamedColor(colorName: string): boolean;
  * @returns Array of all CSS named color names
  */
 export declare function getNamedColors(): string[];
+export declare const DEFAULT_NAMED_COLOR: NamedColors;
+export declare const NAMED_COLOR_SCHEMA: {
+    type: string;
+    title: string;
+    description: string;
+    enum: string[];
+    default: NamedColors.Black;
+};

package/lib/models/style/ng-style-attribute.d.ts

@@ -0,0 +1,14 @@
+export type ngStyleAttribute = {
+    [key: string]: string | number | null;
+};
+export declare const DEFAULT_NG_STYLE: ngStyleAttribute;
+export declare const NG_STYLE_SCHEMA: {
+    type: string;
+    title: string;
+    description: string;
+    additionalProperties: {
+        type: string[];
+        title: string;
+        description: string;
+    };
+};

package/lib/models/style/on-style.d.ts

@@ -1,4 +1,4 @@
-import { ngStyleItem } from './ng-style-item';
+import { ngStyleAttribute } from './ng-style-attribute';
 export interface OnStyle {
-    ngOnStyle(ngStyle: ngStyleItem): ngStyleItem;
+    ngOnStyle(ngStyle: ngStyleAttribute): ngStyleAttribute;
 }