@omnia/fx-sp 8.0.72-vnext → 8.0.73-dev

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

@@ -1,81 +1,439 @@
-import { GuidValue, PromotedTagOptions } from "../../../models";
-import { PromotedTagStore } from "../../../../fx/stores";
-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;
-    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<TermPickerTreeProps> {
-    termStore: TermStore;
-    private subscriptionHandler;
-    promotedTagStore: PromotedTagStore;
-    loc: TermPickerLocalization.locInterface;
-    termSetId: GuidValue;
-    preSelectedTermIds: Array<GuidValue>;
-    multi: boolean;
-    allowCreateNewTerm: boolean;
-    lcid: number;
-    termsSelected: (termIds: Array<GuidValue>) => void;
-    filterOptions: (term: Term) => FilterOption;
-    startWiths: Array<TermData>;
-    maxLevel: number;
-    currentRovingTabIndex: number;
-    closeMenu?: () => void;
-    loaded: () => void;
-    includeDeprecated?: boolean;
-    selectedTerms: Array<TermData>;
-    isEnterpriseKeyword?: boolean;
-    promotedTagOptions?: PromotedTagOptions;
-    maxHeight: number;
-    private startIdToRender;
-    private termClasses;
-    private promotedTermTags;
-    private UIConfig;
-    private treeNodes;
-    private nodeVirtualList;
-    private virtualScrollRef;
-    private openCreateUIForTerm;
-    created(): void;
-    mounted(): void;
-    private init;
-    private generateVirtualTermList;
-    private generateVirtualTermListRecursive;
-    private onCompletedEnsureTerms;
-    private ensurePromotedTermTags;
-    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;
-    private renderTermTree;
-    render(): JSX.Element;
-}
-export {};
+import { GuidValue } from "@omnia/fx-models";
+export declare const TermPickerTree: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        "max-height": {
+            type: import("vue").PropType<number>;
+        };
+        maxHeight: {
+            type: import("vue").PropType<number>;
+        };
+        "promoted-tag-options": {
+            type: import("vue").PropType<any>;
+        };
+        promotedTagOptions: {
+            type: import("vue").PropType<any>;
+        };
+        isEnterpriseKeyword: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "selected-terms": {
+            type: import("vue").PropType<Term[]>;
+        };
+        selectedTerms: {
+            type: import("vue").PropType<Term[]>;
+        };
+        includeDeprecated: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        loaded: {
+            type: import("vue").PropType<() => void>;
+        } & {
+            type: import("vue").PropType<() => void>;
+        };
+        "close-menu": {
+            type: import("vue").PropType<() => void>;
+        };
+        closeMenu: {
+            type: import("vue").PropType<() => void>;
+        };
+        "current-roving-tab-index": {
+            type: import("vue").PropType<number>;
+        };
+        currentRovingTabIndex: {
+            type: import("vue").PropType<number>;
+        };
+        "max-level": {
+            type: import("vue").PropType<number>;
+        };
+        maxLevel: {
+            type: import("vue").PropType<number>;
+        };
+        "start-withs": {
+            type: import("vue").PropType<Term[]>;
+        };
+        startWiths: {
+            type: import("vue").PropType<Term[]>;
+        };
+        "filter-options": {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        filterOptions: {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        "terms-selected": {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        termsSelected: {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        lcid: {
+            type: import("vue").PropType<number>;
+        } & {
+            type: import("vue").PropType<number>;
+        };
+        allowCreateNewTerm: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        multi: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: GuidValue[]) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        "term-set-id": {
+            type: import("vue").PropType<GuidValue>;
+        };
+        termSetId: {
+            type: import("vue").PropType<GuidValue>;
+        };
+    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        "max-height": {
+            type: import("vue").PropType<number>;
+        };
+        maxHeight: {
+            type: import("vue").PropType<number>;
+        };
+        "promoted-tag-options": {
+            type: import("vue").PropType<any>;
+        };
+        promotedTagOptions: {
+            type: import("vue").PropType<any>;
+        };
+        isEnterpriseKeyword: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "selected-terms": {
+            type: import("vue").PropType<Term[]>;
+        };
+        selectedTerms: {
+            type: import("vue").PropType<Term[]>;
+        };
+        includeDeprecated: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        loaded: {
+            type: import("vue").PropType<() => void>;
+        } & {
+            type: import("vue").PropType<() => void>;
+        };
+        "close-menu": {
+            type: import("vue").PropType<() => void>;
+        };
+        closeMenu: {
+            type: import("vue").PropType<() => void>;
+        };
+        "current-roving-tab-index": {
+            type: import("vue").PropType<number>;
+        };
+        currentRovingTabIndex: {
+            type: import("vue").PropType<number>;
+        };
+        "max-level": {
+            type: import("vue").PropType<number>;
+        };
+        maxLevel: {
+            type: import("vue").PropType<number>;
+        };
+        "start-withs": {
+            type: import("vue").PropType<Term[]>;
+        };
+        startWiths: {
+            type: import("vue").PropType<Term[]>;
+        };
+        "filter-options": {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        filterOptions: {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        "terms-selected": {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        termsSelected: {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        lcid: {
+            type: import("vue").PropType<number>;
+        } & {
+            type: import("vue").PropType<number>;
+        };
+        allowCreateNewTerm: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        multi: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: GuidValue[]) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        "term-set-id": {
+            type: import("vue").PropType<GuidValue>;
+        };
+        termSetId: {
+            type: import("vue").PropType<GuidValue>;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        "max-height": {
+            type: import("vue").PropType<number>;
+        };
+        maxHeight: {
+            type: import("vue").PropType<number>;
+        };
+        "promoted-tag-options": {
+            type: import("vue").PropType<any>;
+        };
+        promotedTagOptions: {
+            type: import("vue").PropType<any>;
+        };
+        isEnterpriseKeyword: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "selected-terms": {
+            type: import("vue").PropType<Term[]>;
+        };
+        selectedTerms: {
+            type: import("vue").PropType<Term[]>;
+        };
+        includeDeprecated: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        loaded: {
+            type: import("vue").PropType<() => void>;
+        } & {
+            type: import("vue").PropType<() => void>;
+        };
+        "close-menu": {
+            type: import("vue").PropType<() => void>;
+        };
+        closeMenu: {
+            type: import("vue").PropType<() => void>;
+        };
+        "current-roving-tab-index": {
+            type: import("vue").PropType<number>;
+        };
+        currentRovingTabIndex: {
+            type: import("vue").PropType<number>;
+        };
+        "max-level": {
+            type: import("vue").PropType<number>;
+        };
+        maxLevel: {
+            type: import("vue").PropType<number>;
+        };
+        "start-withs": {
+            type: import("vue").PropType<Term[]>;
+        };
+        startWiths: {
+            type: import("vue").PropType<Term[]>;
+        };
+        "filter-options": {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        filterOptions: {
+            type: import("vue").PropType<(term: Term) => FilterOption>;
+        };
+        "terms-selected": {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        termsSelected: {
+            type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+        };
+        lcid: {
+            type: import("vue").PropType<number>;
+        } & {
+            type: import("vue").PropType<number>;
+        };
+        allowCreateNewTerm: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        multi: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: GuidValue[]) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<GuidValue[]>;
+            required: false;
+        };
+        "term-set-id": {
+            type: import("vue").PropType<GuidValue>;
+        };
+        termSetId: {
+            type: import("vue").PropType<GuidValue>;
+        };
+    }>>, () => JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    "max-height": {
+        type: import("vue").PropType<number>;
+    };
+    maxHeight: {
+        type: import("vue").PropType<number>;
+    };
+    "promoted-tag-options": {
+        type: import("vue").PropType<any>;
+    };
+    promotedTagOptions: {
+        type: import("vue").PropType<any>;
+    };
+    isEnterpriseKeyword: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    "selected-terms": {
+        type: import("vue").PropType<Term[]>;
+    };
+    selectedTerms: {
+        type: import("vue").PropType<Term[]>;
+    };
+    includeDeprecated: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    loaded: {
+        type: import("vue").PropType<() => void>;
+    } & {
+        type: import("vue").PropType<() => void>;
+    };
+    "close-menu": {
+        type: import("vue").PropType<() => void>;
+    };
+    closeMenu: {
+        type: import("vue").PropType<() => void>;
+    };
+    "current-roving-tab-index": {
+        type: import("vue").PropType<number>;
+    };
+    currentRovingTabIndex: {
+        type: import("vue").PropType<number>;
+    };
+    "max-level": {
+        type: import("vue").PropType<number>;
+    };
+    maxLevel: {
+        type: import("vue").PropType<number>;
+    };
+    "start-withs": {
+        type: import("vue").PropType<Term[]>;
+    };
+    startWiths: {
+        type: import("vue").PropType<Term[]>;
+    };
+    "filter-options": {
+        type: import("vue").PropType<(term: Term) => FilterOption>;
+    };
+    filterOptions: {
+        type: import("vue").PropType<(term: Term) => FilterOption>;
+    };
+    "terms-selected": {
+        type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+    };
+    termsSelected: {
+        type: import("vue").PropType<(termIds: Array<GuidValue>) => void>;
+    };
+    lcid: {
+        type: import("vue").PropType<number>;
+    } & {
+        type: import("vue").PropType<number>;
+    };
+    allowCreateNewTerm: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    multi: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: GuidValue[]) => any>;
+    };
+    "v-model": {
+        type: import("vue").PropType<GuidValue[]>;
+        required: false;
+    };
+    modelValue: {
+        type: import("vue").PropType<GuidValue[]>;
+        required: false;
+    };
+    "term-set-id": {
+        type: import("vue").PropType<GuidValue>;
+    };
+    termSetId: {
+        type: import("vue").PropType<GuidValue>;
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        maxHeight?: number;
+        "onUpdate:modelValue"?: (value: GuidValue[]) => any;
+        "v-model"?: GuidValue[];
+        modelValue?: GuidValue[];
+        "max-height"?: number;
+        multi?: boolean;
+        termSetId?: GuidValue;
+        lcid?: number;
+        filterOptions?: (term: Term) => FilterOption;
+        promotedTagOptions?: any;
+        isEnterpriseKeyword?: boolean;
+        "term-set-id"?: GuidValue;
+        allowCreateNewTerm?: boolean;
+        "filter-options"?: (term: Term) => FilterOption;
+        includeDeprecated?: boolean;
+        "promoted-tag-options"?: any;
+        closeMenu?: () => void;
+        "close-menu"?: () => void;
+        termsSelected?: (termIds: Array<GuidValue>) => void;
+        "terms-selected"?: (termIds: Array<GuidValue>) => void;
+        startWiths?: Term[];
+        "start-withs"?: Term[];
+        maxLevel?: number;
+        "max-level"?: number;
+        currentRovingTabIndex?: number;
+        "current-roving-tab-index"?: number;
+        loaded?: () => void;
+        selectedTerms?: Term[];
+        "selected-terms"?: Term[];
+    }>, never>;
+};

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

@@ -1,4 +1,4 @@
-export declare module TermPickerLocalization {
+export declare namespace TermPickerLocalization {
     const namespace = "Omnia.TermPicker";
     interface locInterface {
         CREATE: string;

package/internal-do-not-import-from-here/ux/termsetpicker/TermSetPicker.d.ts

@@ -20,16 +20,16 @@ export declare class TermSetPicker extends VueComponentBase implements IWebCompo
     filled: boolean;
     onChanged: (termSetId: GuidValue) => void;
     styles: {
-        title?: any;
-        content?: any;
-        scrollable?: any;
-        termGroupWrapper?: any;
-        termSetWrapper?: any;
-        selectedTermSetWrapper?: any;
-        arrowBtnCollapsedDefault?: any;
-        arrowBtnExpanded?: any;
-        contentHide?: any;
-        arrowWrapper?: any;
+        termGroupWrapper: string;
+        termSetWrapper: string;
+        selectedTermSetWrapper: string;
+        scrollable: (maxHeight: number) => string;
+        arrowBtnCollapsedDefault: string;
+        arrowBtnExpanded: string;
+        arrowWrapper: string;
+        title: string;
+        content: string;
+        contentHide: string;
     };
     isLoading: boolean;
     internalTermSetId: GuidValue;

package/internal-do-not-import-from-here/ux/termsetpicker/loc/localize.d.ts

@@ -1,4 +1,4 @@
-export declare module TermSetPickerLocalization {
+export declare namespace TermSetPickerLocalization {
     const namespace = "Omnia.TermSetPicker";
     interface locInterface {
         SelectedTermSetNotFound: string;

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

@@ -1,4 +1,4 @@
-export declare module UserPropertyProviderLocalization {
+export declare namespace UserPropertyProviderLocalization {
     interface locInterface {
         UserPropertiesBySharePointProvider: {
             Name: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-sp",
   "license": "MIT",
-  "version": "8.0.72-vnext",
+  "version": "8.0.73-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": "8.0.72-vnext",
-    "@omnia/fx-sp-models": "8.0.72-vnext"
+    "@omnia/fx": "8.0.73-dev",
+    "@omnia/fx-sp-models": "8.0.73-dev"
   },
   "typings": "./index.d.ts",
   "bugs": {

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

@@ -1,18 +0,0 @@
-import { Guid, GuidValue, LockStatusExcludeChildren, PropertyDisplaySettingsBase, PropertyLockStatusType, PropertyValue } from "@omnia/fx-models";
-export type SharePointTermSetPropertySetupSettings = {
-    termSetId: GuidValue;
-};
-export type SharePointTermSetPropertyDisplaySettings = {
-    locks?: PropertyLockStatusType<LockStatusExcludeChildren<Omit<SharePointTermSetPropertyDisplaySettings, "locks">, "label">>;
-    textOnly?: boolean;
-} & PropertyDisplaySettingsBase;
-export type SharePointTermSetPropertyEditorSettings = {
-    locks?: PropertyLockStatusType<Omit<SharePointTermSetPropertyEditorSettings, "locks">>;
-    multiple?: boolean;
-    required?: boolean;
-};
-export declare const sharePointTermSetPropertyDefinitionId: Guid;
-export declare class SharePointTermSetPropertyValue extends PropertyValue {
-    termIds: Guid[];
-    constructor(termIds: Guid[]);
-}

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

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharePointTermSetPropertyValue = exports.sharePointTermSetPropertyDefinitionId = void 0;
-const fx_models_1 = require("@omnia/fx-models");
-exports.sharePointTermSetPropertyDefinitionId = new fx_models_1.Guid("73b6db0e-27f2-45d6-b57d-1f18db45f182");
-class SharePointTermSetPropertyValue extends fx_models_1.PropertyValue {
-    constructor(termIds) {
-        super();
-        this.termIds = termIds;
-    }
-}
-exports.SharePointTermSetPropertyValue = SharePointTermSetPropertyValue;

package/internal-do-not-import-from-here/ux/queryfilterbuilder/IQueryFilterBuilder.d.ts

@@ -1,17 +0,0 @@
-import { TsxAllowUnknowProperties } from "@omnia/fx/ux";
-import { QueryFilter } from "../../../models";
-export interface IQueryFilterBuilder {
-    valueBind: QueryFilter[];
-    onValueChanged: (queryFilters: QueryFilter[]) => void;
-}
-declare global {
-    namespace JSX {
-        interface Element {
-        }
-        interface ElementClass {
-        }
-        interface IntrinsicElements {
-            "omfx-query-filter-builder": TsxAllowUnknowProperties<IQueryFilterBuilder>;
-        }
-    }
-}

package/internal-do-not-import-from-here/ux/queryfilterbuilder/index.d.ts

@@ -1 +0,0 @@
-export * from "./IQueryFilterBuilder";