@omnia/fx-models 7.8.81-preview → 7.8.83-preview

package/ManifestIds.d.ts

@@ -192,6 +192,7 @@ export declare class OmniaWebComponentManifests {
     static get FxUxMenuBlade(): Guid;
     static get FxUxWizard(): Guid;
     static get FxUxPeoplePicker(): Guid;
+    static get FxUxSkeletonLoader(): Guid;
     static get FxUxIcon(): Guid;
     static get FxUxButton(): Guid;
     static get FxUxDatatable(): Guid;

package/ManifestIds.js

@@ -592,6 +592,9 @@ class OmniaWebComponentManifests {
     static get FxUxPeoplePicker() {
         return new models_1.Guid("4893dcff-9223-448c-9259-367a1b4ad652");
     }
+    static get FxUxSkeletonLoader() {
+        return new models_1.Guid("4ecc3b27-de00-4525-8b22-cba846f79ad9");
+    }
     static get FxUxIcon() {
         return new models_1.Guid("EC34A224-751B-4124-B150-3174AC3868F1");
     }

package/filterbuilder/index.d.ts

@@ -2,4 +2,4 @@ export * from "./FilterComponent";
 export * from "./FilterBuilder";
 export * from "./FilterOperatorBuilder";
 export * from "./helper/FilterHelper";
-export * from "./transformers/FilterTransformer";
+export * from "./transformers";

package/filterbuilder/index.js

@@ -5,4 +5,4 @@ tslib_1.__exportStar(require("./FilterComponent"), exports);
 tslib_1.__exportStar(require("./FilterBuilder"), exports);
 tslib_1.__exportStar(require("./FilterOperatorBuilder"), exports);
 tslib_1.__exportStar(require("./helper/FilterHelper"), exports);
-tslib_1.__exportStar(require("./transformers/FilterTransformer"), exports);
+tslib_1.__exportStar(require("./transformers"), exports);

package/filterbuilder/transformers/OmniaSearchFilterTransformer.d.ts

@@ -0,0 +1,9 @@
+import { FilterComponent } from "../FilterComponent";
+import { IFilterTransformer } from "./FilterTransformer";
+export declare class OmniaSearchFilterTransformer implements IFilterTransformer<string> {
+    transform(filters: FilterComponent[]): string;
+    private transformFilterCondition;
+    private transformFilterLogicalOperator;
+    private transformFilterExpressionOperator;
+    private getQueryStringValue;
+}

package/filterbuilder/transformers/OmniaSearchFilterTransformer.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniaSearchFilterTransformer = void 0;
+const QueryFilter_1 = require("../../QueryFilter");
+const FilterComponent_1 = require("../FilterComponent");
+class OmniaSearchFilterTransformer {
+    transform(filters) {
+        let result = "";
+        filters.forEach((filter, index) => {
+            if (index !== 0) {
+                result += this.transformFilterLogicalOperator(filter.filterLogicalOperator);
+            }
+            if (filter instanceof FilterComponent_1.FilterConditionComponent) {
+                result += this.transformFilterCondition(filter);
+            }
+            else if (filter instanceof FilterComponent_1.FilterExpressionComponent) {
+                result += this.transformFilterExpressionOperator(filter);
+            }
+        });
+        return result;
+    }
+    transformFilterCondition(filterCondition) {
+        let operatorString = "";
+        let valueString = "";
+        let firstValue = null;
+        if (!filterCondition.values) {
+            valueString = "NULL";
+            if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Eq) {
+                operatorString = " IS ";
+            }
+            else if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Ne) {
+                operatorString = " IS NOT ";
+            }
+            else {
+                throw new Error("Invalid operator for NULL value.");
+            }
+        }
+        else {
+            firstValue = filterCondition.values[0];
+            if (firstValue == null) {
+                if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Eq) {
+                    return `(${filterCondition.propertyName} IS NULL OR ${filterCondition.propertyName} IS EMPTY OR ${filterCondition.propertyName} NOT EXISTS)`;
+                }
+                else if (filterCondition.filterOperator === QueryFilter_1.FilterOperator.Ne) {
+                    return `(${filterCondition.propertyName} IS NOT NULL AND ${filterCondition.propertyName} IS NOT EMPTY)`;
+                }
+                else {
+                    throw new Error("Invalid operator for NULL value.");
+                }
+            }
+            valueString = this.getQueryStringValue(firstValue);
+            switch (filterCondition.filterOperator) {
+                case QueryFilter_1.FilterOperator.Eq:
+                    operatorString = "=";
+                    break;
+                case QueryFilter_1.FilterOperator.Ne:
+                    operatorString = "!=";
+                    break;
+                case QueryFilter_1.FilterOperator.Gt:
+                    operatorString = ">";
+                    break;
+                case QueryFilter_1.FilterOperator.Lt:
+                    operatorString = "<";
+                    break;
+                case QueryFilter_1.FilterOperator.Ge:
+                    operatorString = ">=";
+                    break;
+                case QueryFilter_1.FilterOperator.Le:
+                    operatorString = "<=";
+                    break;
+                case QueryFilter_1.FilterOperator.In:
+                    operatorString = " IN ";
+                    valueString = `[${filterCondition.values.map((x) => this.getQueryStringValue(x)).join(", ")}]`;
+                    break;
+                case QueryFilter_1.FilterOperator.NotIn:
+                    operatorString = " IN ";
+                    valueString = `[${filterCondition.values.map((x) => this.getQueryStringValue(x)).join(", ")}]`;
+                    return `NOT ${filterCondition.propertyName}${operatorString}${valueString}`;
+                default:
+                    operatorString = " = ";
+                    break;
+            }
+        }
+        if (!operatorString) {
+            throw new Error(`Invalid operator ${filterCondition.filterOperator}`);
+        }
+        return `${filterCondition.propertyName}${operatorString}${valueString}`;
+    }
+    transformFilterLogicalOperator(filterLogicalOperator) {
+        switch (filterLogicalOperator) {
+            case QueryFilter_1.FilterLogicalOperator.And:
+                return " AND ";
+            case QueryFilter_1.FilterLogicalOperator.Or:
+                return " OR ";
+            default:
+                throw new Error(`Invalid logical operator: ${filterLogicalOperator}`);
+        }
+    }
+    transformFilterExpressionOperator(filterExpressionComponent) {
+        const innerExpressionString = this.transform(filterExpressionComponent.filters);
+        return `(${innerExpressionString})`;
+    }
+    getQueryStringValue(value) {
+        if (value == null) {
+            return "";
+        }
+        else if (typeof value === "number") {
+            return value.toString();
+        }
+        else if (typeof value === "boolean") {
+            return `${value}`;
+        }
+        return `"${value.toString()}"`;
+    }
+}
+exports.OmniaSearchFilterTransformer = OmniaSearchFilterTransformer;

package/filterbuilder/transformers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OmniaSearchFilterTransformer";
+export * from "./FilterTransformer";

package/filterbuilder/transformers/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./OmniaSearchFilterTransformer"), exports);
+tslib_1.__exportStar(require("./FilterTransformer"), exports);

package/omniasearch/IPagedSearchResult.d.ts

@@ -1,8 +1,10 @@
 import { ISearchResult } from "./ISearchResult";
 import { IndexedDocument } from "./IndexedDocument";
+import { OmniaRefiner } from "./OmniaRefiner";
 export interface IPagedSearchResultToken {
 }
 export interface IPagedSearchResult<TIndexedDocument extends IndexedDocument> extends ISearchResult<TIndexedDocument> {
     totalPages: number;
     error: string;
+    refiners?: Array<OmniaRefiner>;
 }

package/omniasearch/SearchQuery.d.ts

@@ -4,4 +4,5 @@ export interface SearchQuery {
     filter: Array<Array<string>>;
     sort: Array<string>;
     retrieveProperties: Array<string>;
+    refiners?: Array<string>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-models",
   "license": "MIT",
-  "version": "7.8.81-preview",
+  "version": "7.8.83-preview",
   "description": "Provide Omnia Fx Models Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/properties/PropertyValuePrimitiveConverter.d.ts

@@ -1,4 +1,5 @@
-import { PropertyValue } from "@omnia/fx-models";
+import { PropertyConfiguration, PropertyValue } from "@omnia/fx-models";
 export declare abstract class PropertyValuePrimitiveConverter {
     abstract toPrimitiveString(propertyValue: PropertyValue): string;
+    abstract toDisplayString(propertyValue: PropertyValue, propertyConfiguration?: PropertyConfiguration<any>): Promise<string>;
 }