@omnia/fx-sp 7.0.429-dev → 7.0.431-dev

package/internal-do-not-import-from-here/models/CentralImageLocationItem.d.ts

@@ -1,4 +1,4 @@
-import { ImageItem } from "../../models";
+import { ImageItem } from "@omnia/fx-models";
 export interface CentralImageLocationItem extends ImageItem {
     id: number;
     thumbnailWidth: number;

package/internal-do-not-import-from-here/models/Contexts.d.ts

@@ -1,4 +1,4 @@
-import { OmniaBootstrapData } from "../../models";
+import { OmniaBootstrapData } from "@omnia/fx-models";
 import { GuidValue } from "@omnia/fx-models";
 export interface OmniaSharePointBootstrapData extends OmniaBootstrapData {
     sharepoint: {

package/internal-do-not-import-from-here/models/FilterEngine.d.ts

@@ -1,5 +1,4 @@
-import { BaseFilterEngineProperty, FilterEngineContext, FilterEngineOperator, PropertyIndexedType, TypedFilterEnginePropertyOutput } from "../../models";
-import { GuidValue } from "../../shared";
+import { GuidValue, BaseFilterEngineProperty, FilterEngineContext, FilterEngineOperator, PropertyIndexedType, TypedFilterEnginePropertyOutput } from "@omnia/fx-models";
 export interface TaxonomyFilterEngineProperty extends BaseFilterEngineProperty {
     value: Array<GuidValue>;
     type: PropertyIndexedType.Taxonomy | PropertyIndexedType.EnterpriseKeywords;

package/internal-do-not-import-from-here/models/FilterEngine.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SPSearchFilterEngineContext = exports.FilterEngineTaxonomyValueSortOrder = void 0;
-const models_1 = require("../../models");
+const fx_models_1 = require("@omnia/fx-models");
 var FilterEngineTaxonomyValueSortOrder;
 (function (FilterEngineTaxonomyValueSortOrder) {
     FilterEngineTaxonomyValueSortOrder[FilterEngineTaxonomyValueSortOrder["TermsetOrder"] = 0] = "TermsetOrder";
     FilterEngineTaxonomyValueSortOrder[FilterEngineTaxonomyValueSortOrder["Count"] = 1] = "Count";
 })(FilterEngineTaxonomyValueSortOrder = exports.FilterEngineTaxonomyValueSortOrder || (exports.FilterEngineTaxonomyValueSortOrder = {}));
-class SPSearchFilterEngineContext extends models_1.FilterEngineContext {
+class SPSearchFilterEngineContext extends fx_models_1.FilterEngineContext {
     constructor(componentId) {
         super(componentId);
         this.componentId = componentId;

package/internal-do-not-import-from-here/models/Library.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from "../../models";
+import { GuidValue } from "@omnia/fx-models";
 export interface LibraryResolveResult {
     resolved: boolean;
     libraryId: string;

package/internal-do-not-import-from-here/models/ReservedSiteAliasValidation.d.ts

@@ -1,4 +1,4 @@
-import { AppInstance, GuidValue } from "../../models";
+import { AppInstance, GuidValue } from "@omnia/fx-models";
 export interface ReservedSiteAliasValidationResult {
     isReserved: boolean;
     appInstance: AppInstance;

package/internal-do-not-import-from-here/models/TargetingFilterProperty.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from "../../models";
+import { GuidValue } from "@omnia/fx-models";
 export interface EnterprisePropertiesSettings {
     termIds: Array<GuidValue>;
     includeChildTerms: boolean;

package/internal-do-not-import-from-here/models/Term.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from "../../models";
+import { GuidValue } from "@omnia/fx-models";
 export interface Term extends TermBase {
     parentId: GuidValue;
     termSetId: GuidValue;

package/internal-do-not-import-from-here/models/TermSetPropertyValue.d.ts

@@ -1,8 +1,8 @@
 import { Guid, GuidValue, PrimitiveArray, PropertyDisplaySettingsBase, PropertyValueBase } from "@omnia/fx-models";
-export declare type TermSetDisplaySettings = {
+export declare type SharePointTermSetPropertyDisplaySettings = {
     termSetId: GuidValue;
 } & PropertyDisplaySettingsBase;
-export declare type TermSetEditorSettings = {
+export declare type SharePointTermSetPropertyEditorSettings = {
     multiple?: boolean;
     required?: boolean;
 };

package/internal-do-not-import-from-here/models/permissions/SiteGroup.d.ts

@@ -1,5 +1,5 @@
 import { AssociatedGroup } from "../Enums";
-import { Identity } from "../../../models";
+import { Identity } from "@omnia/fx-models";
 export interface SiteGroup {
     id: number;
     title: string;

package/internal-do-not-import-from-here/models/permissions/SiteGroupMembership.d.ts

@@ -1,7 +1,7 @@
-import { ResolvedUserIdentity } from "../../../models";
+import { Identity } from "@omnia/fx-models";
 export interface SiteGroupMembership {
     spUrl: string;
     memberships: {
-        [siteGroupId: number]: Array<ResolvedUserIdentity>;
+        [siteGroupId: number]: Array<Identity>;
     };
 }

package/internal-do-not-import-from-here/stores/SharePointUserStore.d.ts

@@ -10,13 +10,13 @@ export declare class SharePointUserStore extends Store {
     actions: {
         updateUserProfilePropertiesValues: import("@omnia/../../fx/stores").StoreAction<unknown, (properties: {
             [propertyName: string]: SharePointUserProfilePropertyValueBase;
-        }) => void, (result: string[], properties: {
+        }) => void, (result: void, properties: {
             [propertyName: string]: SharePointUserProfilePropertyValueBase;
         }) => void, (failureReason: any, properties: {
             [propertyName: string]: SharePointUserProfilePropertyValueBase;
         }) => void, (properties: {
             [propertyName: string]: SharePointUserProfilePropertyValueBase;
-        }) => Promise<string[]>>;
+        }) => Promise<void>>;
         getUserProfilePropertyNames: import("@omnia/../../fx/stores").StoreAction<unknown, () => void, (result: string[]) => void, (failureReason: any) => void, () => Promise<string[]>>;
         getUserProfilePropertiesValues: import("@omnia/../../fx/stores").StoreAction<unknown, (user: UserIdentity) => void, (result: {
             [name: string]: string;

package/internal-do-not-import-from-here/ux/filterengine/handler/TaxonomyFilterEngineHandler.d.ts

@@ -13,9 +13,10 @@ export default class TaxonomyFilterEngineHandler extends Store implements ITyped
     hideTitle: boolean;
     private termSetId;
     private customSortOrderHash;
-    private latestRefiner;
+    private latestRefinements;
     private selectedRefinements;
     private mediator;
+    private refinerName;
     /**
      *
      */
@@ -51,8 +52,6 @@ export default class TaxonomyFilterEngineHandler extends Store implements ITyped
     };
     private getTermSetId;
     init(): Promise<void>;
-    generateQueryText(): string;
-    generateRefinerFilter(): string;
     isRefinable(): boolean;
     isolatedRefinementEnabled(): boolean;
     getManagedProperty(): string;

package/internal-do-not-import-from-here/ux/filterengine/shared/SPSearchUtils.d.ts

@@ -2,4 +2,7 @@ import { FilterEngineSPSearchOutput, FilterQuery } from "@omnia/fx/models";
 import { FilterEngineHandler } from "@omnia/fx/ux";
 export declare module SPSearchUtils {
     function mergeFilter(query: FilterQuery, filterEngineHandler: FilterEngineHandler): FilterEngineSPSearchOutput;
+    function getInternalName(managedProperty: string): string;
+    function getQueryableManagedProperty(internalName: string): string;
+    function getRefinableManagedProperty(propertyName: string): string;
 }

package/internal-do-not-import-from-here/ux/properties/term-set/TermSetPropertyDefinition.d.ts

@@ -1,6 +1,6 @@
 import { PropertyDefinition } from "@omnia/fx-models";
-import { SharePointTermSetPropertyValue, TermSetDisplaySettings, TermSetEditorSettings } from "@omnia/fx-sp-models";
-export declare class SharePointTermSetPropertyDefinition extends PropertyDefinition<SharePointTermSetPropertyValue, TermSetDisplaySettings, TermSetEditorSettings> {
+import { SharePointTermSetPropertyValue, SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyEditorSettings } from "@omnia/fx-sp-models";
+export declare class SharePointTermSetPropertyDefinition extends PropertyDefinition<SharePointTermSetPropertyValue, SharePointTermSetPropertyDisplaySettings, SharePointTermSetPropertyEditorSettings> {
     id: import("@omnia/fx-models").Guid;
     typeName: string;
 }

package/internal-do-not-import-from-here/ux/termpicker/TermPickerTree.d.ts

@@ -1,24 +1,30 @@
-import { IWebComponentInstance } from "../../../";
-import { TermPickerLocalization } from "./loc/localize";
-import { TermStore, TermData } from "../../../fx/stores";
-import { Term, FilterOption } from "../../models";
 import { GuidValue, PromotedTagOptions } from "../../../models";
-import { ITermPickerTree } from "./ITermPickerTree";
-import "./TermPicker.css";
-import { VueComponentBase } from "../../../ux";
 import { PromotedTagStore } from "../../../../fx/stores";
-interface TermTreeViewNode extends Term {
-    selected?: boolean;
-    expanding?: boolean;
-    creating?: boolean;
-    loadingChildren?: boolean;
-    currentRovingTabIndex?: number;
-    closeMenu?: () => void;
-    level: number;
+import { VueComponentBase } from "../../../ux";
+import { FilterOption, Term } from "../../models";
+import { TermData, TermStore } from "../../../fx/stores";
+import { TermPickerLocalization } from "./loc/localize";
+import "./TermPicker.css";
+interface TermPickerTreeProps {
+    startWiths: Array<TermData>;
+    termSetId: GuidValue;
+    preSelectedTermIds?: Array<GuidValue>;
+    lcid?: number;
+    termsSelected?: (termIds: Array<GuidValue>) => void;
+    filterOptions?: (term: Term) => FilterOption;
     loaded: () => void;
-    notShowExpandedIcon?: boolean;
+    selectedTerms: Array<TermData>;
+    promotedTagOptions?: PromotedTagOptions;
+    multi?: boolean;
+    allowCreateNewTerm?: boolean;
+    maxLevel: number;
+    currentRovingTabIndex: number;
+    closeMenu?: () => void;
+    includeDeprecated?: boolean;
+    isEnterpriseKeyword?: boolean;
+    maxHeight: number;
 }
-export declare class TermPickerTree extends VueComponentBase<ITermPickerTree> implements IWebComponentInstance, ITermPickerTree {
+export declare class TermPickerTree extends VueComponentBase<TermPickerTreeProps> {
     termStore: TermStore;
     private subscriptionHandler;
     promotedTagStore: PromotedTagStore;
@@ -39,34 +45,35 @@ export declare class TermPickerTree extends VueComponentBase<ITermPickerTree> im
     selectedTerms: Array<TermData>;
     isEnterpriseKeyword?: boolean;
     promotedTagOptions?: PromotedTagOptions;
+    maxHeight: number;
     private startIdToRender;
     private termClasses;
     private promotedTermTags;
     private UIConfig;
-    treeNodes: {
-        [parentId: string]: Array<TermTreeViewNode>;
-    };
+    private treeNodes;
+    private nodeVirtualList;
+    private openCreateUIForTerm;
     created(): void;
     mounted(): void;
-    init(): void;
+    private init;
+    private generateVirtualTermList;
     private onCompletedEnsureTerms;
     private ensurePromotedTermTags;
-    createNewTerm(parentTerm: TermTreeViewNode, termName: string): void;
-    validateTermName(parentId: string, name: string): boolean;
-    getChildrens(parentId: any): TermTreeViewNode[];
-    applyFilter(term: Term): boolean;
-    isDisableNode(term: any): boolean;
-    mapToTreeNode(node: Term, isAvailableForTagging?: boolean): TermTreeViewNode;
-    getDisplayLabel(termId: string): string;
-    dispatchEnsureChildTerm(term: TermTreeViewNode): void;
-    isFullLoaded(parentId: GuidValue): boolean;
-    addToDictionary(treeParentId: GuidValue, parentIdToGetChildren?: GuidValue, term?: Term): void;
-    sortByCustomSortOrder(treeNodes: Array<Term>, customSortOrder: string): Term[];
-    onBeforeExpandCollapse(term: TermTreeViewNode): void;
-    onBeforeCreateNewChildTerm(term: TermTreeViewNode): void;
-    onTermSelecting(term: TermTreeViewNode): void;
-    render(): VueTsxSupport.JSX.Element;
+    private createNewTerm;
+    private validateTermName;
+    private applyFilter;
+    private isDisableNode;
+    private mapToTreeNode;
+    private getDisplayLabel;
+    private dispatchEnsureChildTerm;
+    private isFullLoaded;
+    private addToDictionary;
+    private sortByCustomSortOrder;
+    private onBeforeExpandCollapse;
+    private onBeforeCreateNewChildTerm;
+    private onTermSelecting;
     private renderPromotedTerms;
-    renderTermTree(parentId: GuidValue, nodeLevel: number): VueTsxSupport.JSX.Element;
+    private renderTermTree;
+    render(h: any): VueTsxSupport.JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/user/UserPropertiesBySharePointDefinition.d.ts

@@ -1,8 +1,10 @@
 import { Guid, PropertyDefinition, PropertyValueBase, UserPropertyConfiguration } from "@omnia/fx-models";
+import { SharePointUserProfilePropertyValueBase } from "@omnia/fx-sp-models";
 export declare class SharePointUserPropertyValue extends PropertyValueBase {
-    value: string;
+    valueToRender: string;
+    valueToUpdate: SharePointUserProfilePropertyValueBase;
     primitive: null;
-    constructor(value: string);
+    constructor(valueToRender: string, valueToUpdate?: SharePointUserProfilePropertyValueBase);
 }
 export declare type SharePointUserPropertyDisplaySettings = {};
 export declare type SharePointUserPropertyEditorSettings = {};
@@ -10,6 +12,8 @@ export declare class UserPropertiesBySharePointDefinition extends PropertyDefini
     id: Guid;
     typeName: string;
     hidden: boolean;
-    static createPropertyValue(configuration: UserPropertyConfiguration, spValue: SharePointUserPropertyValue): PropertyValueBase;
-    static getPropertyValue(configuration: UserPropertyConfiguration, value: PropertyValueBase): SharePointUserPropertyValue;
+    private static userIdentityStore;
+    private static termStore;
+    static createPropertyValue(configuration: UserPropertyConfiguration, spValue: SharePointUserPropertyValue): Promise<PropertyValueBase>;
+    static createSharePointUserPropertyValue(configuration: UserPropertyConfiguration, value: PropertyValueBase): SharePointUserPropertyValue;
 }

package/internal-do-not-import-from-here/ux/user/UserPropertiesBySharePointEditor.d.ts

@@ -1,8 +1,8 @@
-import { IPropertyProviderDisplayRenderer } from "@omnia/fx-models";
+import { IPropertyProviderEditorRenderer } from "@omnia/fx-models";
 import { UserPropertiesBySharePointDefinition } from "./UserPropertiesBySharePointDefinition";
-declare const msgraphUserEditorComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyProviderDisplayRenderer<UserPropertiesBySharePointDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyProviderDisplayRenderer<UserPropertiesBySharePointDefinition>, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyProviderDisplayRenderer<UserPropertiesBySharePointDefinition>, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyProviderDisplayRenderer<UserPropertiesBySharePointDefinition>, never>;
+declare const msgraphUserEditorComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyProviderEditorRenderer<UserPropertiesBySharePointDefinition>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyProviderEditorRenderer<UserPropertiesBySharePointDefinition>, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyProviderEditorRenderer<UserPropertiesBySharePointDefinition>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyProviderEditorRenderer<UserPropertiesBySharePointDefinition>, never>;
 });
 export default msgraphUserEditorComponent;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-sp",
   "license": "MIT",
-  "version": "7.0.429-dev",
+  "version": "7.0.431-dev",
   "description": "Provide Omnia Fx Sharepoint Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx": "7.0.429-dev",
-    "@omnia/fx-sp-models": "7.0.429-dev"
+    "@omnia/fx": "7.0.431-dev",
+    "@omnia/fx-sp-models": "7.0.431-dev"
   },
   "typings": "./index.d.ts",
   "bugs": {

package/internal-do-not-import-from-here/ux/termpicker/ITermPickerTree.d.ts

@@ -1,35 +0,0 @@
-import { TsxAllowUnknowProperties } from "../../../ux";
-import { Term, FilterOption } from "../../models";
-import { GuidValue, PromotedTagOptions } from "../../../models";
-import { TermData } from "../../../fx/stores";
-export interface ITermPickerTreeProperties {
-    multi?: boolean;
-    allowCreateNewTerm?: boolean;
-    maxLevel: number;
-    currentRovingTabIndex: number;
-    closeMenu?: () => void;
-    includeDeprecated?: boolean;
-    isEnterpriseKeyword?: boolean;
-}
-export interface ITermPickerTree extends ITermPickerTreeProperties {
-    startWiths: Array<TermData>;
-    termSetId: GuidValue;
-    preSelectedTermIds?: Array<GuidValue>;
-    lcid?: number;
-    termsSelected?: (termIds: Array<GuidValue>) => void;
-    filterOptions?: (term: Term) => FilterOption;
-    loaded: () => void;
-    selectedTerms: Array<TermData>;
-    promotedTagOptions?: PromotedTagOptions;
-}
-declare global {
-    namespace VueTsxSupport.JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-term-picker-tree": TsxAllowUnknowProperties<ITermPickerTree>;
-        }
-    }
-}