@pnp/spfx-property-controls 3.22.0 → 3.23.0-beta.2200135

package/lib/services/PnPTermStorePickerService.js

@@ -8,20 +8,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { TermStorePickerServiceHelper } from "./ISPTermStorePickerService";
-import { taxonomy, StringMatchOption } from "@pnp/sp-taxonomy";
+import { SPHttpClient } from "@microsoft/sp-http";
 /**
- * Term Store Picker Service implementation that uses @pnp/sp-taxonomy to work with taxonomy service
+ * Term Store Picker Service implementation that uses SharePoint REST API for taxonomy
+ * This replaces the old @pnp/sp-taxonomy which is no longer available in PnPjs v4
  */
 export default class PnPTermStorePickerService {
     constructor(props, context) {
         this.props = props;
-        this.context = context;
         this._termSetCollectionObjectType = 'SP.Taxonomy.TermSetCollection';
         this._termGroupCollectionObjectType = 'SP.Taxonomy.TermGroupCollection';
-        this._pnpGroups = {};
-        taxonomy.setup({
-            spfxContext: context
-            //globalCacheDisable: true // uncomment this one for debugging with no cache
+        this._groups = {};
+        // No initialization needed - we use SPHttpClient from context
+        this.context = context;
+    }
+    /**
+     * Makes a request to the taxonomy REST API
+     * @param endpoint - The endpoint path after /v2.1/_api/
+     */
+    _taxonomyRequest(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.context.pageContext.web.absoluteUrl}/_api/v2.1/${endpoint}`;
+            const response = yield this.context.spHttpClient.get(url, SPHttpClient.configurations.v1);
+            if (!response.ok) {
+                throw new Error(`Taxonomy API request failed: ${response.statusText}`);
+            }
+            return response.json();
         });
     }
     /**
@@ -30,22 +42,7 @@ export default class PnPTermStorePickerService {
     getTermStores() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
-            const result = [];
-            this._pnpTermStores.forEach(pnpTermStore => {
-                result.push({
-                    _ObjectType_: 'SP.Taxonomy.TermStore',
-                    _ObjectIdentity_: pnpTermStore._ObjectIdentity_, // eslint-disable-line @typescript-eslint/no-explicit-any
-                    Id: pnpTermStore.Id,
-                    Name: pnpTermStore.Name,
-                    Groups: {
-                        _ObjectType_: this._termGroupCollectionObjectType,
-                        _Child_Items_: this._pnpGroups[pnpTermStore.Id].map(g => {
-                            return this._pnpTermGroup2TermGroup(g, pnpTermStore);
-                        })
-                    }
-                });
-            });
-            return result;
+            return this._termStores;
         });
     }
     /**
@@ -54,13 +51,13 @@ export default class PnPTermStorePickerService {
      */
     searchTermsByName(searchText) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.props.limitByTermsetNameOrID) { // search in specific term(s)
+            if (this.props.limitByTermsetNameOrID) {
                 return this._searchTermsByTermSet(searchText);
             }
-            else if (this.props.limitByGroupNameOrID) { // search in specific group
+            else if (this.props.limitByGroupNameOrID) {
                 return this._searchTermsByGroup(searchText);
             }
-            else { // search everywhere
+            else {
                 return this._searchAllTerms(searchText);
             }
         });
@@ -70,44 +67,20 @@ export default class PnPTermStorePickerService {
      */
     getTermSets() {
         return __awaiter(this, void 0, void 0, function* () {
-            let termSets = [];
             yield this._ensureTermStores();
-            for (let i = 0, len = this._pnpTermStores.length; i < len; i++) {
-                const pnpTermStore = this._pnpTermStores[i];
-                if (this.props.limitByTermsetNameOrID) {
-                    const pnpTermSets = yield this._getPnPTermSetsByNameOrId(pnpTermStore, this.props.limitByTermsetNameOrID);
-                    const groupsBatch = taxonomy.createBatch();
-                    for (let termSetIdx = 0, termSetLen = pnpTermSets.length; termSetIdx < termSetLen; termSetIdx++) {
-                        const pnpTermSet = pnpTermSets[termSetIdx];
-                        const termSet = this._pnpTermSet2TermSet(pnpTermSet, '');
-                        termSets.push(termSet);
-                        pnpTermSet.group.inBatch(groupsBatch).usingCaching().get().then(pnpTermGroup => {
-                            termSet.Group = TermStorePickerServiceHelper.cleanGuid(pnpTermGroup.Id);
-                        }).catch(() => { });
-                    }
-                    yield groupsBatch.execute();
-                }
-                else {
-                    let pnpGroups;
-                    if (this.props.limitByGroupNameOrID) {
-                        const pnpGroup = this._getPnPTermGroupsByNameOrId(pnpTermStore.Id, this.props.limitByGroupNameOrID);
-                        pnpGroups = [];
-                        if (pnpGroup) {
-                            pnpGroups.push(pnpGroup);
-                        }
+            let termSets = [];
+            for (const termStore of this._termStores) {
+                const groups = this._groups[termStore.Id];
+                for (const group of groups) {
+                    if (this.props.limitByTermsetNameOrID) {
+                        // Filter to specific term set
+                        const filteredTermSets = group.TermSets._Child_Items_.filter(ts => ts.Name === this.props.limitByTermsetNameOrID ||
+                            ts.Id.toLowerCase() === this.props.limitByTermsetNameOrID.toLowerCase());
+                        termSets = [...termSets, ...filteredTermSets];
                     }
                     else {
-                        pnpGroups = this._pnpGroups[pnpTermStore.Id];
+                        termSets = [...termSets, ...group.TermSets._Child_Items_];
                     }
-                    const batch = taxonomy.createBatch();
-                    pnpGroups.forEach(pnpGroup => {
-                        pnpGroup.termSets.inBatch(batch).usingCaching().get().then(pnpTermSets => {
-                            termSets = [...termSets, ...pnpTermSets.map(pnpTermSet => {
-                                    return this._pnpTermSet2TermSet(pnpTermSet, TermStorePickerServiceHelper.cleanGuid(pnpGroup.Id));
-                                })];
-                        }).catch(() => { });
-                    });
-                    yield batch.execute();
                 }
             }
             return termSets;
@@ -120,33 +93,50 @@ export default class PnPTermStorePickerService {
     getAllTerms(termSet) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
-            const pnpTermStores = this._pnpTermStores;
-            for (const pnpTermStore of pnpTermStores) {
-                const termsResult = yield this._tryGetAllTerms(pnpTermStore, termSet).catch((error) => { }); // .catch part is needed to proceed if there was a rejected promise
-                if (!termsResult) { // terms variable will be undefined if the Promise has been rejected. Otherwise it will contain an array
-                    continue;
-                }
-                const pnpTerms = termsResult;
+            try {
+                // Use the new taxonomy REST API to get terms
+                const response = yield this._taxonomyRequest(`termStore/sets/${termSet.Id}/terms?$expand=children`);
                 const resultTerms = [];
-                const labelsBatch = taxonomy.createBatch();
-                for (let termIdx = 0, termsLen = pnpTerms.length; termIdx < termsLen; termIdx++) {
-                    const pnpTerm = pnpTerms[termIdx];
-                    const term = pnpTerm;
-                    term.Id = TermStorePickerServiceHelper.cleanGuid(term.Id);
-                    term.PathDepth = term.PathOfTerm.split(';').length;
-                    term.TermSet = termSet;
-                    resultTerms.push(term);
-                    if (this.props.includeLabels) {
-                        pnpTerm.labels.inBatch(labelsBatch).usingCaching().get().then(labels => {
-                            term.Labels = labels.map(label => label.Value);
-                        }).catch(() => { });
+                // Recursively process terms to build flat list with paths
+                const processTerms = (terms, parentPath = '', depth = 1) => {
+                    for (const taxonomyTerm of terms) {
+                        const termName = this._getDefaultLabel(taxonomyTerm);
+                        const pathOfTerm = parentPath ? `${parentPath};${termName}` : termName;
+                        const term = {
+                            _ObjectType_: 'SP.Taxonomy.Term',
+                            _ObjectIdentity_: taxonomyTerm.id,
+                            Id: taxonomyTerm.id,
+                            Name: termName,
+                            Description: this._getDescription(taxonomyTerm),
+                            IsDeprecated: taxonomyTerm.isDeprecated || false,
+                            IsAvailableForTagging: taxonomyTerm.isAvailableForTagging !== false,
+                            IsRoot: depth === 1,
+                            PathOfTerm: pathOfTerm,
+                            PathDepth: depth,
+                            TermSet: {
+                                _ObjectType_: 'SP.Taxonomy.TermSet',
+                                _ObjectIdentity_: termSet.Id,
+                                Id: termSet.Id,
+                                Name: termSet.Name
+                            }
+                        };
+                        if (this.props.includeLabels) {
+                            term.Labels = taxonomyTerm.labels.map(l => l.name);
+                        }
+                        resultTerms.push(term);
+                        // Process children recursively
+                        if (taxonomyTerm.children && taxonomyTerm.children.length > 0) {
+                            processTerms(taxonomyTerm.children, pathOfTerm, depth + 1);
+                        }
                     }
-                }
-                if (this.props.includeLabels) {
-                    yield labelsBatch.execute();
-                }
+                };
+                processTerms(response.value);
                 return TermStorePickerServiceHelper.sortTerms(resultTerms);
             }
+            catch (error) {
+                console.error('Error loading terms', error);
+                return [];
+            }
         });
     }
     /**
@@ -154,357 +144,232 @@ export default class PnPTermStorePickerService {
      * @param group Term Group
      */
     getGroupTermSets(group) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
-            const pnpTermStore = this._pnpTermStores.filter(ts => TermStorePickerServiceHelper.cleanGuid(ts.Id) === group.TermStore.Id)[0];
-            const pnpGroups = this._pnpGroups[pnpTermStore.Id].filter(gr => TermStorePickerServiceHelper.cleanGuid(gr.Id) === group.Id); //await pnpTermStore.getTermGroupById(group.Id).usingCaching().get();
-            if (!pnpGroups || !pnpGroups.length) {
+            const groupData = (_b = this._groups[((_a = group.TermStore) === null || _a === void 0 ? void 0 : _a.Id) || this._termStoreId]) === null || _b === void 0 ? void 0 : _b.find(g => g.Id === group.Id);
+            if (!groupData) {
                 return {
                     _ObjectType_: this._termSetCollectionObjectType,
                     _Child_Items_: []
                 };
             }
-            const pnpGroup = pnpGroups[0];
-            let pnpTermSets;
+            let termSets = groupData.TermSets._Child_Items_;
             if (this.props.limitByTermsetNameOrID) {
-                const isGuid = TermStorePickerServiceHelper.isGuid(this.props.limitByTermsetNameOrID);
-                if (isGuid) {
-                    pnpTermSets = [yield pnpGroup.termSets.getById(this.props.limitByTermsetNameOrID).usingCaching().get()];
-                }
-                else {
-                    pnpTermSets = [yield pnpGroup.termSets.getByName(this.props.limitByTermsetNameOrID).usingCaching().get()];
-                }
-            }
-            else {
-                pnpTermSets = yield pnpGroup.termSets.usingCaching().get();
+                termSets = termSets.filter(ts => ts.Name === this.props.limitByTermsetNameOrID ||
+                    ts.Id.toLowerCase() === this.props.limitByTermsetNameOrID.toLowerCase());
             }
-            const result = {
+            return {
                 _ObjectType_: this._termSetCollectionObjectType,
-                _Child_Items_: pnpTermSets.map(pnpTermSet => {
-                    return this._pnpTermSet2TermSet(pnpTermSet, TermStorePickerServiceHelper.cleanGuid(pnpGroup.Id));
-                })
+                _Child_Items_: termSets
             };
-            return result;
-        });
-    }
-    /**
-     * Tries to get terms from the specified Term Set.
-     * @param pnpTermStore Term Store to work with
-     * @param termSet Term set to get terms from
-     */
-    _tryGetAllTerms(pnpTermStore, termSet) {
-        return new Promise((resolve, reject) => {
-            pnpTermStore.getTermSetById(termSet.Id).terms.usingCaching().get().then((pnpTerms) => {
-                resolve(pnpTerms);
-            }, (error) => {
-                reject(error);
-            });
         });
     }
     /**
-     * Searches terms by provided text in the term sets specified by the this.props.limitByTermSetNameOrId
-     * @param searchText text to search
+     * Searches terms by provided text in the term sets specified by limitByTermsetNameOrID
      */
     _searchTermsByTermSet(searchText) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
             const returnTerms = [];
-            const pnpTermStores = this._pnpTermStores;
-            //
-            // iterating through term stores
-            //
-            for (let i = 0, len = pnpTermStores.length; i < len; i++) {
-                const pnpTermStore = pnpTermStores[i];
-                const pnpTermSets = yield this._getPnPTermSetsByNameOrId(pnpTermStore, this.props.limitByTermsetNameOrID);
-                // getting filtered terms from term sets
-                returnTerms.push(...yield this._searchTermsInTermSets(pnpTermStore, pnpTermSets, searchText));
+            const termSets = yield this.getTermSets();
+            for (const termSet of termSets) {
+                const terms = yield this.getAllTerms(termSet);
+                const filtered = this._filterTermsBySearch(terms, searchText);
+                for (const term of filtered) {
+                    returnTerms.push(this._termToPickerTerm(term, termSet));
+                }
             }
             return returnTerms;
         });
     }
     /**
-     * Searches terms by provided text in the term sets specified by the this.props.limitByGroupNameOrId
-     * @param searchText text to search
+     * Searches terms by provided text in the group specified by limitByGroupNameOrID
      */
     _searchTermsByGroup(searchText) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
-            const groupNameOrID = this.props.limitByGroupNameOrID;
             const returnTerms = [];
-            const pnpTermStores = this._pnpTermStores;
-            //
-            // iterating through term stores
-            //
-            for (let i = 0, len = pnpTermStores.length; i < len; i++) {
-                const pnpTermStore = pnpTermStores[i];
-                const pnpGroup = this._getPnPTermGroupsByNameOrId(pnpTermStore.Id, groupNameOrID);
-                if (!pnpGroup) {
-                    continue;
+            for (const termStore of this._termStores) {
+                const groups = this._groups[termStore.Id];
+                const targetGroup = groups.find(g => g.Name === this.props.limitByGroupNameOrID ||
+                    g.Id.toLowerCase() === this.props.limitByGroupNameOrID.toLowerCase());
+                if (targetGroup) {
+                    for (const termSet of targetGroup.TermSets._Child_Items_) {
+                        const terms = yield this.getAllTerms(termSet);
+                        const filtered = this._filterTermsBySearch(terms, searchText);
+                        for (const term of filtered) {
+                            const pickerTerm = this._termToPickerTerm(term, termSet);
+                            pickerTerm.termGroup = targetGroup.Id;
+                            returnTerms.push(pickerTerm);
+                        }
+                    }
                 }
-                // getting term sets from term group
-                const pnpTermSets = yield pnpGroup.termSets.usingCaching().get();
-                // getting filtered terms from term sets
-                returnTerms.push(...yield this._searchTermsInTermSets(pnpTermStore, pnpTermSets, searchText, pnpGroup.Id));
             }
             return returnTerms;
         });
     }
     /**
-     * Searches for terms in the term store
-     * @param searchText text to search
+     * Searches for terms across all term stores
      */
     _searchAllTerms(searchText) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._ensureTermStores();
-            const pnpTermStores = this._pnpTermStores;
             const returnTerms = [];
-            //
-            // iterating through term stores
-            //
-            for (let i = 0, len = pnpTermStores.length; i < len; i++) {
-                const pnpTermStore = pnpTermStores[i];
-                // searching for terms that starts with provided string
-                const pnpTerms = yield pnpTermStore.getTerms({
-                    TermLabel: searchText,
-                    StringMatchOption: StringMatchOption.StartsWith,
-                    DefaultLabelOnly: true,
-                    TrimUnavailable: true,
-                    ResultCollectionSize: 30
-                }).usingCaching().get();
-                const batch = taxonomy.createBatch();
-                //
-                // processing each term to get termSet info and labels
-                //
-                pnpTerms.forEach(pnpTerm => {
-                    const pickerTerm = {
-                        key: TermStorePickerServiceHelper.cleanGuid(pnpTerm.Id),
-                        name: pnpTerm.Name,
-                        path: pnpTerm.PathOfTerm,
-                        termSet: '',
-                        termGroup: ''
-                    };
-                    returnTerms.push(pickerTerm);
-                    pnpTerm.termSet.group.inBatch(batch).usingCaching().get().then(pnpTermGroup => {
-                        pickerTerm.termGroup = TermStorePickerServiceHelper.cleanGuid(pnpTermGroup.Id);
-                    }).catch(() => { });
-                    pnpTerm.termSet.inBatch(batch).usingCaching().get().then(pnpTermSet => {
-                        pickerTerm.termSet = TermStorePickerServiceHelper.cleanGuid(pnpTermSet.Id);
-                        pickerTerm.termSetName = pnpTermSet.Name;
-                    }).catch(() => { });
-                    if (this.props.includeLabels) {
-                        pnpTerm.labels.inBatch(batch).usingCaching().get().then(labels => {
-                            pickerTerm.labels = labels.map(label => label.Value);
-                        }).catch(() => { });
+            for (const termStore of this._termStores) {
+                const groups = this._groups[termStore.Id];
+                for (const group of groups) {
+                    for (const termSet of group.TermSets._Child_Items_) {
+                        const terms = yield this.getAllTerms(termSet);
+                        const filtered = this._filterTermsBySearch(terms, searchText);
+                        for (const term of filtered) {
+                            const pickerTerm = this._termToPickerTerm(term, termSet);
+                            pickerTerm.termGroup = group.Id;
+                            returnTerms.push(pickerTerm);
+                        }
                     }
-                });
-                yield batch.execute();
+                }
             }
             return returnTerms;
         });
     }
     /**
-     * Searches for terms by provided text in specified term sets
-     * @param pnpTermStore Term Store
-     * @param pnpTermSets term sets where the terms should be searched for
-     * @param searchText text to search
-     * @param termGroupId Id of the group that contains the term sets
+     * Filters terms by search text (starts with, case-insensitive)
      */
-    _searchTermsInTermSets(pnpTermStore, pnpTermSets, searchText, termGroupId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const returnTerms = [];
-            const termSetGroups = {};
-            const termsBatch = taxonomy.createBatch();
-            const labelsBatch = taxonomy.createBatch();
-            const lowerCasedSearchText = searchText.toLowerCase();
-            for (let termSetIdx = 0, termSetLen = pnpTermSets.length; termSetIdx < termSetLen; termSetIdx++) {
-                const pnpTermSet = pnpTermSets[termSetIdx];
-                const pnpTermSetGuid = TermStorePickerServiceHelper.cleanGuid(pnpTermSet.Id);
-                if (!termGroupId) { // if no group id provided we need to load it from store
-                    pnpTermSet.group.inBatch(termsBatch).usingCaching().get().then(pnpTermGroup => {
-                        termSetGroups[pnpTermSet.Id] = pnpTermGroup.Id;
-                        const loadedTerms = returnTerms.filter(t => t.termSet === pnpTermSetGuid);
-                        loadedTerms.forEach(t => {
-                            t.termGroup = TermStorePickerServiceHelper.cleanGuid(pnpTermGroup.Id);
-                        });
-                    }).catch(() => { });
-                }
-                // getting terms for term set in batch
-                pnpTermSet.terms.inBatch(termsBatch).usingCaching().get().then(pnpTerms => {
-                    for (let termIdx = 0, termLen = pnpTerms.length; termIdx < termLen; termIdx++) {
-                        const pnpTerm = pnpTerms[termIdx];
-                        if (pnpTerm.Name.toLowerCase().indexOf(lowerCasedSearchText) === 0) {
-                            const pickerTerm = {
-                                key: TermStorePickerServiceHelper.cleanGuid(pnpTerm.Id),
-                                name: pnpTerm.Name,
-                                path: pnpTerm.PathOfTerm,
-                                termSet: TermStorePickerServiceHelper.cleanGuid(pnpTermSetGuid),
-                                termSetName: pnpTermSet.Name,
-                                termGroup: termGroupId || TermStorePickerServiceHelper.cleanGuid(termSetGroups[pnpTermSet.Id])
-                            };
-                            returnTerms.push(pickerTerm);
-                            // getting labels for each term in a separate batch
-                            if (this.props.includeLabels) {
-                                pnpTerm.labels.inBatch(labelsBatch).usingCaching().get().then(pnpLabels => {
-                                    pickerTerm.labels = pnpLabels.map(l => l.Value);
-                                }).catch(() => { });
-                            }
-                        }
-                    }
-                }).catch(() => { });
-            }
-            //
-            // executing batches
-            //
-            yield termsBatch.execute();
-            if (this.props.includeLabels) {
-                yield labelsBatch.execute();
-            }
-            return returnTerms;
-        });
+    _filterTermsBySearch(terms, searchText) {
+        const lowerSearch = searchText.toLowerCase();
+        return terms.filter(t => t.Name.toLowerCase().startsWith(lowerSearch)).slice(0, 30);
+    }
+    /**
+     * Converts an ITerm to an IPickerTerm
+     */
+    _termToPickerTerm(term, termSet) {
+        const pickerTerm = {
+            key: term.Id,
+            name: term.Name,
+            path: term.PathOfTerm,
+            termSet: termSet.Id,
+            termSetName: termSet.Name,
+            termGroup: ''
+        };
+        if (term.Labels) {
+            pickerTerm.labels = term.Labels;
+        }
+        return pickerTerm;
     }
     /**
-     * Ensures (loads if needed) term stores and term groups from taxonomy service
+     * Ensures term stores and groups are loaded
      */
     _ensureTermStores() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._pnpTermStores) {
-                this._pnpTermStores = yield taxonomy.termStores.usingCaching().get();
-                // TODO: limit by group or termset
-                for (let i = 0, len = this._pnpTermStores.length; i < len; i++) {
-                    const pnpTermStore = this._pnpTermStores[i];
-                    let pnpGroups;
-                    if (this.props.limitByGroupNameOrID) {
-                        const group = yield this._requestPnPTermGroupByNameOrId(pnpTermStore, this.props.limitByGroupNameOrID);
-                        pnpGroups = [];
-                        if (group) {
-                            pnpGroups.push(group);
-                        }
-                    }
-                    else if (this.props.limitByTermsetNameOrID) {
-                        const pnpTermSets = yield this._getPnPTermSetsByNameOrId(pnpTermStore, this.props.limitByTermsetNameOrID);
-                        pnpGroups = [];
-                        const groupsBatch = taxonomy.createBatch();
-                        pnpTermSets.forEach(pnpTermSet => {
-                            pnpTermSet.group.inBatch(groupsBatch).usingCaching().get().then(pnpGroup => {
-                                if (!pnpGroups.filter(gr => gr.Id === pnpGroup.Id).length) {
-                                    pnpGroups.push(pnpGroup);
-                                }
-                            }).catch(() => { });
+            if (this._termStores) {
+                return;
+            }
+            try {
+                // Get the default term store
+                const termStoreInfo = yield this._taxonomyRequest('termStore');
+                this._termStoreId = termStoreInfo.id;
+                // Get all groups in the term store
+                const groupsResponse = yield this._taxonomyRequest('termStore/groups');
+                let groups = groupsResponse.value;
+                // Filter by group if specified
+                if (this.props.limitByGroupNameOrID) {
+                    groups = groups.filter(g => g.name === this.props.limitByGroupNameOrID ||
+                        g.id.toLowerCase() === this.props.limitByGroupNameOrID.toLowerCase());
+                }
+                // Exclude system groups if specified
+                if (this.props.excludeSystemGroup) {
+                    groups = groups.filter(g => g.type !== 'systemGroup');
+                }
+                // Build the groups with their term sets
+                const processedGroups = [];
+                for (const taxonomyGroup of groups) {
+                    // Get term sets for this group
+                    const termSetsResponse = yield this._taxonomyRequest(`termStore/groups/${taxonomyGroup.id}/sets`);
+                    let termSets = termSetsResponse.value;
+                    // Filter by term set if specified
+                    if (this.props.limitByTermsetNameOrID) {
+                        termSets = termSets.filter(ts => {
+                            var _a, _b;
+                            const name = ((_a = ts.localizedNames.find(n => n.languageTag === termStoreInfo.defaultLanguageTag)) === null || _a === void 0 ? void 0 : _a.name) || ((_b = ts.localizedNames[0]) === null || _b === void 0 ? void 0 : _b.name);
+                            return name === this.props.limitByTermsetNameOrID ||
+                                ts.id.toLowerCase() === this.props.limitByTermsetNameOrID.toLowerCase();
                         });
-                        yield groupsBatch.execute();
                     }
-                    else {
-                        pnpGroups = yield pnpTermStore.groups.usingCaching().get();
+                    const group = {
+                        _ObjectType_: 'SP.Taxonomy.TermGroup',
+                        _ObjectIdentity_: taxonomyGroup.id,
+                        Id: taxonomyGroup.id,
+                        Name: taxonomyGroup.name,
+                        IsSystemGroup: taxonomyGroup.type === 'systemGroup',
+                        TermStore: {
+                            Id: termStoreInfo.id,
+                            Name: termStoreInfo.name
+                        },
+                        TermSets: {
+                            _ObjectType_: this._termSetCollectionObjectType,
+                            _Child_Items_: termSets.map(ts => this._convertTermSet(ts, termStoreInfo.defaultLanguageTag, taxonomyGroup.id))
+                        }
+                    };
+                    // Only add groups that have term sets (after filtering)
+                    if (group.TermSets._Child_Items_.length > 0 || !this.props.limitByTermsetNameOrID) {
+                        processedGroups.push(group);
                     }
-                    this._pnpGroups[pnpTermStore.Id] = pnpGroups;
                 }
+                this._groups[termStoreInfo.id] = processedGroups;
+                // Build the term store result
+                this._termStores = [{
+                        _ObjectType_: 'SP.Taxonomy.TermStore',
+                        _ObjectIdentity_: termStoreInfo.id,
+                        Id: termStoreInfo.id,
+                        Name: termStoreInfo.name,
+                        Groups: {
+                            _ObjectType_: this._termGroupCollectionObjectType,
+                            _Child_Items_: processedGroups
+                        }
+                    }];
+            }
+            catch (error) {
+                console.error('Error loading term stores', error);
+                this._termStores = [];
             }
         });
     }
     /**
-     * Converts @pnp/sp-taxonomy Term Set instance into internal ITermSet object
-     * @param pnpTermSet @pnp/sp-taxonomy Term Set instance
-     * @param groupId Id of the group that contains the term set
+     * Converts a taxonomy API term set to the internal ITermSet format
      */
-    _pnpTermSet2TermSet(pnpTermSet, groupId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const anyPnPTermSet = pnpTermSet; // we need this one to reference _ObjectType_ and _ObjectIdentity_
+    _convertTermSet(taxonomyTermSet, defaultLanguage, groupId) {
+        var _a, _b;
+        const defaultName = ((_a = taxonomyTermSet.localizedNames.find(n => n.languageTag === defaultLanguage)) === null || _a === void 0 ? void 0 : _a.name) ||
+            ((_b = taxonomyTermSet.localizedNames[0]) === null || _b === void 0 ? void 0 : _b.name) || '';
+        const names = {};
+        taxonomyTermSet.localizedNames.forEach(n => {
+            names[n.languageTag] = n.name;
+        });
         return {
-            _ObjectType_: anyPnPTermSet._ObjectType_,
-            _ObjectIdentity_: anyPnPTermSet._ObjectIdentity_,
-            Id: TermStorePickerServiceHelper.cleanGuid(pnpTermSet.Id),
-            Name: pnpTermSet.Name,
-            Description: pnpTermSet.Description,
-            Names: pnpTermSet.Names,
+            _ObjectType_: 'SP.Taxonomy.TermSet',
+            _ObjectIdentity_: taxonomyTermSet.id,
+            Id: taxonomyTermSet.id,
+            Name: defaultName,
+            Description: taxonomyTermSet.description || '',
+            Names: names,
             Group: groupId
         };
     }
     /**
-     * Converts @pnp/sp-taxonomy Term Group instance into internal IGroup object
-     * @param pnpTermGroup @pnp/sp-taxonomy Term Group instance
-     * @param pnpTermStore @pnp/sp-taxonumy term store to work with
+     * Gets the default label from a taxonomy term
      */
-    _pnpTermGroup2TermGroup(pnpTermGroup, pnpTermStore) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const anyPnPTermGroup = pnpTermGroup; // we need this one to reference _ObjectType_ and _ObjectIdentity_
-        return {
-            _ObjectType_: anyPnPTermGroup._ObjectType_,
-            _ObjectIdentity_: anyPnPTermGroup._ObjectIdentity_,
-            Id: TermStorePickerServiceHelper.cleanGuid(pnpTermGroup.Id),
-            Name: pnpTermGroup.Name,
-            IsSystemGroup: pnpTermGroup.IsSystemGroup,
-            TermStore: {
-                Id: TermStorePickerServiceHelper.cleanGuid(pnpTermStore.Id),
-                Name: pnpTermStore.Name
-            },
-            TermSets: {
-                _ObjectType_: this._termSetCollectionObjectType,
-                _Child_Items_: null
-            }
-        };
-    }
-    /**
-     * Gets term set(s) from taxonomy service by name or id
-     * @param pnpTermStore @pnp/sp-taxonumy term store to work with
-     * @param termSetNameOrID term set name or id
-     */
-    _getPnPTermSetsByNameOrId(pnpTermStore, termSetNameOrID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let pnpTermSets;
-            const isGuid = TermStorePickerServiceHelper.isGuid(termSetNameOrID);
-            //
-            // getting term sets by filter
-            //
-            if (isGuid) {
-                pnpTermSets = [];
-                const pnpTermSet = yield pnpTermStore.getTermSetById(termSetNameOrID).usingCaching().get();
-                if (pnpTermSet.Id) {
-                    pnpTermSets.push(pnpTermSet);
-                }
-            }
-            else {
-                pnpTermSets = yield pnpTermStore.getTermSetsByName(termSetNameOrID, pnpTermStore.DefaultLanguage).usingCaching().get();
-            }
-            return pnpTermSets;
-        });
+    _getDefaultLabel(taxonomyTerm) {
+        var _a;
+        const defaultLabel = taxonomyTerm.labels.find(l => l.isDefault);
+        return (defaultLabel === null || defaultLabel === void 0 ? void 0 : defaultLabel.name) || ((_a = taxonomyTerm.labels[0]) === null || _a === void 0 ? void 0 : _a.name) || '';
     }
     /**
-     * Gets group from cached (previously loaded) list of groups by name or id
-     * @param termStoreId term store id
-     * @param groupNameOrID group name or id
+     * Gets the description from a taxonomy term
      */
-    _getPnPTermGroupsByNameOrId(termStoreId, groupNameOrID) {
-        const isGuid = TermStorePickerServiceHelper.isGuid(groupNameOrID);
-        const pnpTermStoreGroups = this._pnpGroups[termStoreId];
-        if (pnpTermStoreGroups) {
-            const groups = pnpTermStoreGroups.filter(pnpGroup => isGuid ? TermStorePickerServiceHelper.cleanGuid(pnpGroup.Id) === groupNameOrID
-                : pnpGroup.Name === groupNameOrID);
-            if (groups && groups.length) {
-                return groups[0];
-            }
-        }
-        return null;
-    }
-    /**
-     * Gets group from taxonomy service by name or id
-     * @param pnpTermStore @pnp/sp-taxonomy term store to work with
-     * @param groupNameOrID group name or id
-     */
-    _requestPnPTermGroupByNameOrId(pnpTermStore, groupNameOrID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isGuid = TermStorePickerServiceHelper.isGuid(groupNameOrID);
-            let group;
-            if (isGuid) {
-                group = yield pnpTermStore.getTermGroupById(groupNameOrID).usingCaching().get();
-            }
-            else {
-                group = yield pnpTermStore.groups.getByName(groupNameOrID).usingCaching().get();
-            }
-            if (group.Id) {
-                return group;
-            }
-            return null;
-        });
+    _getDescription(taxonomyTerm) {
+        var _a, _b;
+        return ((_b = (_a = taxonomyTerm.descriptions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.description) || '';
     }
 }
 //# sourceMappingURL=PnPTermStorePickerService.js.map