@cccsaurora/howler-ui 2.19.0-dev.1151 → 2.19.0-dev.1260

package/utils/classificationParser.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Classification related utils.
+ *
+ * WARNING:
+ * Actual classification enforcement is handled server side. These utils are convenience functions mostly used for
+ * display purposes. They and are not expected to be used for critical access control enforcement. As such, error
+ * conditions are not raised and suitable default values are returned.
+ *
+ */
+export type FormatProp = 'long' | 'short';
+type LevelStylesheet = {
+    banner?: string;
+    label?: string;
+    text?: string;
+    color?: string;
+};
+type ClassificationLevel = {
+    aliases: string[];
+    css: LevelStylesheet;
+    description: string;
+    lvl: number;
+    name: string;
+    short_name: string;
+    is_hidden?: boolean;
+};
+type ClassificationRequired = {
+    aliases: string[];
+    description: string;
+    name: string;
+    is_required_group?: boolean;
+    require_lvl?: number;
+    short_name: string;
+    is_hidden?: boolean;
+};
+type ClassificationGroup = {
+    aliases: string[];
+    auto_select?: boolean;
+    description: string;
+    name: string;
+    short_name: string;
+    solitary_display_name?: string;
+    is_hidden?: boolean;
+};
+type ClassificationSubGroup = {
+    aliases: string[];
+    auto_select?: boolean;
+    description: string;
+    limited_to_group?: string;
+    name: string;
+    require_group?: string;
+    short_name: string;
+    solitary_display_name?: string;
+    is_hidden?: boolean;
+};
+type ClassificationYAMLDefinition = {
+    dynamic_groups: boolean;
+    dynamic_groups_type: string;
+    enforce: boolean;
+    groups: ClassificationGroup[];
+    levels: ClassificationLevel[];
+    required: ClassificationRequired[];
+    restricted: string;
+    subgroups: ClassificationSubGroup[];
+    unrestricted: string;
+};
+type StringMap = {
+    [propName: string]: string;
+};
+type StringMapArray = {
+    [propName: string]: string[];
+};
+type StylesheetMap = {
+    [propName: string]: LevelStylesheet;
+};
+type ParamsMap = {
+    [propName: string]: {
+        is_required_group?: boolean;
+        solitary_display_name?: string;
+        require_lvl?: number;
+        require_group?: string;
+        limited_to_group?: string;
+        is_hidden?: boolean;
+    };
+};
+export type ClassificationDefinition = {
+    RESTRICTED: string;
+    UNRESTRICTED: string;
+    access_req_aliases: StringMapArray;
+    access_req_map_lts: StringMap;
+    access_req_map_stl: StringMap;
+    description: StringMap;
+    dynamic_groups: boolean;
+    dynamic_groups_type: 'email' | 'group' | 'all';
+    enforce: boolean;
+    groups_aliases: StringMapArray;
+    groups_auto_select: string[];
+    groups_auto_select_short: string[];
+    groups_map_lts: StringMap;
+    groups_map_stl: StringMap;
+    invalid_mode: boolean;
+    levels_aliases: StringMap;
+    levels_map: StringMap;
+    levels_map_lts: StringMap;
+    levels_map_stl: StringMap;
+    levels_styles_map: StylesheetMap;
+    original_definition: ClassificationYAMLDefinition;
+    params_map: ParamsMap;
+    subgroups_aliases: StringMapArray;
+    subgroups_auto_select: string[];
+    subgroups_auto_select_short: string[];
+    subgroups_map_lts: StringMap;
+    subgroups_map_stl: StringMap;
+};
+export type ClassificationParts = {
+    lvlIdx: number;
+    lvl: string;
+    req: string[];
+    groups: string[];
+    subgroups: string[];
+};
+export declare const defaultParts: ClassificationParts;
+type DisabledControls = {
+    levels: string[];
+    groups: string[];
+};
+export declare const defaultDisabled: DisabledControls;
+export declare class InvalidClassification extends Error {
+}
+export declare const getLevelText: (lvl: number, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => string;
+export declare const getParts: (c12n: string, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => ClassificationParts;
+export declare const canSeeRequired: (user_req: string[], req: string[]) => boolean;
+export declare const canSeeGroups: (user_groups: string[], groups: string[]) => boolean;
+/**
+ * Normalize a given classification by applying the rules defined in the classification definition.
+ * This function will remove any invalid parts and add missing parts to the classification.
+ * It will also ensure that the display of the classification is always done the same way
+ *
+ * Note: This function mutates the passed in `parts` parameter.
+ *
+ * @param parts - `ClassificationParts` object containing the parsed classification components
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ * @param skipAutoSelect - `true`/`false` skip auto selecting required groups
+ *
+ * @returns A normalized version of the original classification
+ *
+ */
+export declare const normalizedClassification: (parts: ClassificationParts, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean, skipAutoSelect?: boolean) => string;
+type ClassificationValidator = {
+    disabled: DisabledControls;
+    parts: ClassificationParts;
+};
+export declare const defaultClassificationValidator: ClassificationValidator;
+/**
+ * Applies the Level, Require and Group rules and returns valid and invalid options based on the given input
+ *
+ * @param parts - `ClassificationParts` object containing the parsed classification components
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ * @param userClassification - `true`/`false` if to apply `auto select` based on the user
+ *
+ * @returns The most restrictive classification that we could create out of the two
+ *
+ */
+export declare const applyClassificationRules: (parts: ClassificationParts, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean, userClassification?: boolean) => ClassificationValidator;
+/**
+ * Mixes two classifications and returns to most restrictive form for them
+ *
+ * @param c12n_1 - First classification
+ * @param c12n_2 - Second classification
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ *
+ * @returns The most restrictive classification that we could create out of the two
+ *
+ */
+export declare const getMaxClassification: (c12n_1: string, c12n_2: string, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => string;
+/**
+ *
+ * Given a user classification, check if a user is allow to see a certain classification
+ *
+ * @param user_c12n - Maximum classification for the user
+ * @param c12n - Classification the user wishes to see
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param enforce - `true`/`false` if access controls are enabled
+ * @param ignoreInvalid - `true`/`false` if invalid classifications should raise errors or just deny access
+ *
+ * @returns True is the user can see the classification
+ *
+ */
+export declare const isAccessible: (user_c12n: string, c12n: string, c12nDef: ClassificationDefinition, enforce?: boolean, ignoreInvalid?: boolean) => boolean;
+export {};