@pnp/cli-microsoft365 7.5.0 → 7.6.0-beta.480812d

package/dist/m365/spfx/commands/project/project-azuredevops-pipeline-add.js

@@ -0,0 +1,183 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpfxProjectAzureDevOpsPipelineAddCommand_instances, _a, _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry, _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions, _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators;
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { CommandError } from '../../../../Command.js';
+import commands from '../../commands.js';
+import { BaseProjectCommand } from './base-project-command.js';
+import { validation } from '../../../../utils/validation.js';
+import { pipeline } from './DeployWorkflow.js';
+import { fsUtil } from '../../../../utils/fsUtil.js';
+import { parse } from 'semver';
+class SpfxProjectAzureDevOpsPipelineAddCommand extends BaseProjectCommand {
+    get name() {
+        return commands.PROJECT_AZUREDEVOPS_PIPELINE_ADD;
+    }
+    get description() {
+        return 'Adds a Azure DevOps Pipeline for a SharePoint Framework project.';
+    }
+    constructor() {
+        super();
+        _SpfxProjectAzureDevOpsPipelineAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpfxProjectAzureDevOpsPipelineAddCommand_instances, "m", _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        this.projectRootPath = this.getProjectRoot(process.cwd());
+        if (this.projectRootPath === null) {
+            throw new CommandError(`Couldn't find project root folder`, _a.ERROR_NO_PROJECT_ROOT_FOLDER);
+        }
+        const solutionPackageJsonFile = path.join(this.projectRootPath, 'package.json');
+        const packageJson = fs.readFileSync(solutionPackageJsonFile, 'utf-8');
+        const solutionName = JSON.parse(packageJson).name;
+        if (this.debug) {
+            logger.logToStderr(`Adding Azure DevOps pipeline in the current SPFx project`);
+        }
+        try {
+            this.updatePipeline(solutionName, pipeline, args.options);
+            this.savePipeline(pipeline);
+        }
+        catch (error) {
+            throw new CommandError(error);
+        }
+    }
+    savePipeline(pipeline) {
+        const azureDevOpsPath = path.join(this.projectRootPath, '.azuredevops');
+        fsUtil.ensureDirectory(azureDevOpsPath);
+        const pipelinesPath = path.join(azureDevOpsPath, 'pipelines');
+        fsUtil.ensureDirectory(pipelinesPath);
+        const pipelineFile = path.join(pipelinesPath, 'deploy-spfx-solution.yml');
+        fs.writeFileSync(path.resolve(pipelineFile), yaml.stringify(pipeline), 'utf-8');
+    }
+    updatePipeline(solutionName, pipeline, options) {
+        if (options.name) {
+            pipeline.name = options.name;
+        }
+        else {
+            delete pipeline.name;
+        }
+        if (options.branchName) {
+            pipeline.trigger.branches.include[0] = options.branchName;
+        }
+        const version = this.getProjectVersion();
+        if (!version) {
+            throw `Unable to determine the version of the current SharePoint Framework project`;
+        }
+        const minorVersion = parse(version)?.minor;
+        if (minorVersion === undefined) {
+            throw `Unable to determine the minor version of the current SharePoint Framework project`;
+        }
+        if (minorVersion < 18) {
+            const node = this.getNodeAction(pipeline);
+            if (node.inputs) {
+                node.inputs.versionSpec = '16.x';
+            }
+        }
+        const script = this.getScriptAction(pipeline);
+        if (script.script) {
+            if (options.loginMethod === 'user') {
+                script.script = script.script.replace(`{{login}}`, `m365 login --authType password --userName '$(UserName)' --password '$(Password)'`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'CertificateBase64Encoded' &&
+                    v.name !== 'CertificateSecureFileId' &&
+                    v.name !== 'CertificatePassword' &&
+                    v.name !== 'EntraAppId' &&
+                    v.name !== 'TenantId');
+            }
+            else {
+                script.script = script.script.replace(`{{login}}`, `m365 login --authType certificate --certificateBase64Encoded '$(CertificateBase64Encoded)' --password '$(CertificatePassword)' --appId '$(EntraAppId)' --tenant '$(TenantId)'`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'UserName' &&
+                    v.name !== 'Password');
+            }
+            if (options.scope === 'sitecollection') {
+                script.script = script.script.replace(`{{deploy}}`, `m365 spo app deploy --name '$(PackageName)' --appCatalogScope sitecollection --appCatalogUrl '$(SiteAppCatalogUrl)'`);
+                script.script = script.script.replace(`{{addApp}}`, `m365 spo app add --filePath '$(Build.SourcesDirectory)/sharepoint/solution/$(PackageName)' --appCatalogScope sitecollection --appCatalogUrl '$(SiteAppCatalogUrl)' --overwrite`);
+                this.assignPipelineVariables(pipeline, 'SiteAppCatalogUrl', options.siteUrl);
+            }
+            else {
+                script.script = script.script.replace(`{{deploy}}`, `m365 spo app deploy --name '$(PackageName)' --appCatalogScope 'tenant'`);
+                script.script = script.script.replace(`{{addApp}}`, `m365 spo app add --filePath '$(Build.SourcesDirectory)/sharepoint/solution/$(PackageName)' --overwrite`);
+                pipeline.variables = pipeline.variables.filter(v => v.name !== 'SiteAppCatalogUrl');
+            }
+            if (solutionName) {
+                this.assignPipelineVariables(pipeline, 'PackageName', `${solutionName}.sppkg`);
+            }
+            if (options.skipFeatureDeployment) {
+                script.script = script.script.replace(`m365 spo app deploy `, `m365 spo app deploy --skipFeatureDeployment `);
+            }
+        }
+    }
+    assignPipelineVariables(pipeline, variableName, newVariableValue) {
+        const variable = pipeline.variables.find(v => v.name === variableName);
+        if (variable) {
+            variable.value = newVariableValue;
+        }
+    }
+    getScriptAction(pipeline) {
+        const steps = this.getPipelineSteps(pipeline);
+        return steps.find(step => step.script);
+    }
+    getNodeAction(pipeline) {
+        const steps = this.getPipelineSteps(pipeline);
+        return steps.find(step => step.task && step.task.indexOf('NodeTool') >= 0);
+    }
+    getPipelineSteps(pipeline) {
+        return pipeline.stages[0].jobs[0].steps;
+    }
+}
+_a = SpfxProjectAzureDevOpsPipelineAddCommand, _SpfxProjectAzureDevOpsPipelineAddCommand_instances = new WeakSet(), _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry = function _SpfxProjectAzureDevOpsPipelineAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            name: typeof args.options.name !== 'undefined',
+            branchName: typeof args.options.branchName !== 'undefined',
+            loginMethod: typeof args.options.loginMethod !== 'undefined',
+            scope: typeof args.options.scope !== 'undefined',
+            skipFeatureDeployment: !!args.options.skipFeatureDeployment
+        });
+    });
+}, _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions = function _SpfxProjectAzureDevOpsPipelineAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --name [name]'
+    }, {
+        option: '-b, --branchName [branchName]'
+    }, {
+        option: '-l, --loginMethod [loginMethod]',
+        autocomplete: _a.loginMethod
+    }, {
+        option: '-s, --scope [scope]',
+        autocomplete: _a.scope
+    }, {
+        option: '-u, --siteUrl [siteUrl]'
+    }, {
+        option: '--skipFeatureDeployment'
+    });
+}, _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators = function _SpfxProjectAzureDevOpsPipelineAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.scope && args.options.scope === 'sitecollection') {
+            if (!args.options.siteUrl) {
+                return `siteUrl option has to be defined when scope set to ${args.options.scope}`;
+            }
+            const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.siteUrl);
+            if (isValidSharePointUrl !== true) {
+                return isValidSharePointUrl;
+            }
+        }
+        if (args.options.loginMethod && _a.loginMethod.indexOf(args.options.loginMethod) < 0) {
+            return `${args.options.loginMethod} is not a valid login method. Allowed values are ${_a.loginMethod.join(', ')}`;
+        }
+        if (args.options.scope && _a.scope.indexOf(args.options.scope) < 0) {
+            return `${args.options.scope} is not a valid scope. Allowed values are ${_a.scope.join(', ')}`;
+        }
+        return true;
+    });
+};
+SpfxProjectAzureDevOpsPipelineAddCommand.loginMethod = ['application', 'user'];
+SpfxProjectAzureDevOpsPipelineAddCommand.scope = ['tenant', 'sitecollection'];
+SpfxProjectAzureDevOpsPipelineAddCommand.ERROR_NO_PROJECT_ROOT_FOLDER = 1;
+export default new SpfxProjectAzureDevOpsPipelineAddCommand();
+//# sourceMappingURL=project-azuredevops-pipeline-add.js.map

package/dist/m365/spfx/commands/project/project-azuredevops-pipeline-model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-azuredevops-pipeline-model.js.map

package/dist/m365/spfx/commands/project/project-github-workflow-add.js

@@ -13,6 +13,7 @@ import { validation } from '../../../../utils/validation.js';
 import commands from '../../commands.js';
 import { workflow } from './DeployWorkflow.js';
 import { BaseProjectCommand } from './base-project-command.js';
+import { parse } from 'semver';
 class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
     get name() {
         return commands.PROJECT_GITHUB_WORKFLOW_ADD;
@@ -67,10 +68,8 @@ class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
         if (!version) {
             throw `Unable to determine the version of the current SharePoint Framework project`;
         }
-        const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-        const minorVersionString = match ? match[2] : null;
-        const minorVersion = minorVersionString ? Number(minorVersionString) : null;
-        if (minorVersion === null || isNaN(minorVersion)) {
+        const minorVersion = parse(version)?.minor;
+        if (minorVersion === undefined) {
             throw `Unable to determine the minor version of the current SharePoint Framework project`;
         }
         if (minorVersion < 18) {

package/dist/m365/spfx/commands.js

@@ -2,6 +2,7 @@ const prefix = 'spfx';
 export default {
     DOCTOR: `${prefix} doctor`,
     PACKAGE_GENERATE: `${prefix} package generate`,
+    PROJECT_AZUREDEVOPS_PIPELINE_ADD: `${prefix} project azuredevops pipeline add`,
     PROJECT_DOCTOR: `${prefix} project doctor`,
     PROJECT_EXTERNALIZE: `${prefix} project externalize`,
     PROJECT_GITHUB_WORKFLOW_ADD: `${prefix} project github workflow add`,

package/dist/m365/spo/commands/folder/FolderColor.js

@@ -0,0 +1,19 @@
+export const FolderColorValues = {
+    yellow: '0',
+    darkRed: '1',
+    darkOrange: '2',
+    darkGreen: '3',
+    darkTeal: '4',
+    darkBlue: '5',
+    darkPurple: '6',
+    darkPink: '7',
+    grey: '8',
+    lightRed: '9',
+    lightOrange: '10',
+    lightGreen: '11',
+    lightTeal: '12',
+    lightBlue: '13',
+    lightPurple: '14',
+    lightPink: '15'
+};
+//# sourceMappingURL=FolderColor.js.map

package/dist/m365/spo/commands/folder/folder-add.js

@@ -3,13 +3,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SpoFolderAddCommand_instances, _SpoFolderAddCommand_initOptions, _SpoFolderAddCommand_initValidators, _SpoFolderAddCommand_initTypes;
+var _SpoFolderAddCommand_instances, _SpoFolderAddCommand_initTelemetry, _SpoFolderAddCommand_initOptions, _SpoFolderAddCommand_initValidators, _SpoFolderAddCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
+import { FolderColorValues } from './FolderColor.js';
 class SpoFolderAddCommand extends SpoCommand {
     get name() {
         return commands.FOLDER_ADD;
@@ -20,25 +21,35 @@ class SpoFolderAddCommand extends SpoCommand {
     constructor() {
         super();
         _SpoFolderAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoFolderAddCommand_instances, "m", _SpoFolderAddCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
-        if (this.verbose) {
-            await logger.logToStderr(`Adding folder to site ${args.options.webUrl}...`);
-        }
-        const parentFolderServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.parentFolderUrl);
-        const serverRelativeUrl = `${parentFolderServerRelativeUrl}/${args.options.name}`;
-        const requestUrl = `${args.options.webUrl}/_api/web/folders/addUsingPath(decodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}')`;
-        const requestOptions = {
-            url: requestUrl,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
         try {
+            if (this.verbose) {
+                await logger.logToStderr(`Adding folder to site ${args.options.webUrl}...`);
+            }
+            const parentFolderServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.parentFolderUrl);
+            const serverRelativeUrl = `${parentFolderServerRelativeUrl}/${args.options.name}`;
+            const requestOptions = {
+                headers: {
+                    'accept': 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            if (args.options.color === undefined) {
+                requestOptions.url = `${args.options.webUrl}/_api/web/folders/addUsingPath(decodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}')`;
+            }
+            else {
+                requestOptions.url = `${args.options.webUrl}/_api/foldercoloring/createfolder(DecodedUrl='${formatting.encodeQueryParameter(serverRelativeUrl)}', overwrite=false)`;
+                requestOptions.data = {
+                    coloringInformation: {
+                        ColorHex: FolderColorValues[args.options.color] || args.options.color
+                    }
+                };
+            }
             const folder = await request.post(requestOptions);
             await logger.log(folder);
         }
@@ -47,18 +58,36 @@ class SpoFolderAddCommand extends SpoCommand {
         }
     }
 }
-_SpoFolderAddCommand_instances = new WeakSet(), _SpoFolderAddCommand_initOptions = function _SpoFolderAddCommand_initOptions() {
+_SpoFolderAddCommand_instances = new WeakSet(), _SpoFolderAddCommand_initTelemetry = function _SpoFolderAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            color: typeof args.options.color !== 'undefined'
+        });
+    });
+}, _SpoFolderAddCommand_initOptions = function _SpoFolderAddCommand_initOptions() {
     this.options.unshift({
         option: '-u, --webUrl <webUrl>'
     }, {
         option: '-p, --parentFolderUrl <parentFolderUrl>'
     }, {
         option: '-n, --name <name>'
+    }, {
+        option: '--color [color]',
+        autocomplete: Object.keys(FolderColorValues)
     });
 }, _SpoFolderAddCommand_initValidators = function _SpoFolderAddCommand_initValidators() {
-    this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.webUrl));
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.color && !Object.entries(FolderColorValues).flat().includes(args.options.color)) {
+            return `'${args.options.color}' is not a valid value for option 'color'. Allowed values are ${Object.keys(FolderColorValues).join(', ')}, ${Object.values(FolderColorValues).join(', ')}.`;
+        }
+        return true;
+    });
 }, _SpoFolderAddCommand_initTypes = function _SpoFolderAddCommand_initTypes() {
-    this.types.string.push('webUrl', 'parentFolderUrl', 'name');
+    this.types.string.push('webUrl', 'parentFolderUrl', 'name', 'color');
 };
 export default new SpoFolderAddCommand();
 //# sourceMappingURL=folder-add.js.map

package/dist/m365/spo/commands/folder/folder-set.js

@@ -0,0 +1,118 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SpoFolderSetCommand_instances, _SpoFolderSetCommand_initTelemetry, _SpoFolderSetCommand_initOptions, _SpoFolderSetCommand_initValidators, _SpoFolderSetCommand_initTypes;
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { FolderColorValues } from './FolderColor.js';
+class SpoFolderSetCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SET;
+    }
+    get description() {
+        return 'Updates a folder';
+    }
+    alias() {
+        return [commands.FOLDER_RENAME];
+    }
+    constructor() {
+        super();
+        _SpoFolderSetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSetCommand_instances, "m", _SpoFolderSetCommand_initTypes).call(this);
+    }
+    getExcludedOptionsWithUrls() {
+        return ['url'];
+    }
+    async commandAction(logger, args) {
+        try {
+            await this.showDeprecationWarning(logger, this.alias()[0], this.name);
+            if (this.verbose) {
+                await logger.logToStderr(`Updating folder '${args.options.name}'...`);
+            }
+            const serverRelativePath = urlUtil.getServerRelativePath(args.options.webUrl, args.options.url);
+            if (!args.options.color) {
+                const requestOptions = {
+                    url: `${args.options.webUrl}/_api/Web/GetFolderByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(serverRelativePath)}')/ListItemAllFields`,
+                    headers: {
+                        accept: 'application/json;odata=nometadata',
+                        'if-match': '*'
+                    },
+                    data: {
+                        FileLeafRef: args.options.name,
+                        Title: args.options.name
+                    },
+                    responseType: 'json'
+                };
+                const response = await request.patch(requestOptions);
+                if (response && response['odata.null'] === true) {
+                    throw 'Folder not found.';
+                }
+            }
+            else {
+                const requestOptions = {
+                    url: `${args.options.webUrl}/_api/foldercoloring/${args.options.name ? 'renamefolder' : 'stampcolor'}(DecodedUrl='${formatting.encodeQueryParameter(serverRelativePath)}')`,
+                    headers: {
+                        accept: 'application/json;odata=nometadata'
+                    },
+                    responseType: 'json',
+                    data: {
+                        coloringInformation: {
+                            ColorHex: FolderColorValues[args.options.color] || args.options.color
+                        },
+                        newName: args.options.name
+                    }
+                };
+                await request.post(requestOptions);
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_SpoFolderSetCommand_instances = new WeakSet(), _SpoFolderSetCommand_initTelemetry = function _SpoFolderSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            name: typeof args.options.name !== 'undefined',
+            color: typeof args.options.color !== 'undefined'
+        });
+    });
+}, _SpoFolderSetCommand_initOptions = function _SpoFolderSetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
+        option: '--url <url>'
+    }, {
+        option: '-n, --name [name]'
+    }, {
+        option: '--color [color]',
+        autocomplete: Object.keys(FolderColorValues)
+    });
+}, _SpoFolderSetCommand_initValidators = function _SpoFolderSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.color === undefined && args.options.name === undefined) {
+            return `Specify at least one of the options: name or color.`;
+        }
+        if (args.options.color && !Object.entries(FolderColorValues).flat().includes(args.options.color)) {
+            return `'${args.options.color}' is not a valid value for option 'color'. Allowed values are ${Object.keys(FolderColorValues).join(', ')}, ${Object.values(FolderColorValues).join(', ')}.`;
+        }
+        return true;
+    });
+}, _SpoFolderSetCommand_initTypes = function _SpoFolderSetCommand_initTypes() {
+    this.types.string.push('webUrl', 'url', 'name', 'color');
+};
+export default new SpoFolderSetCommand();
+//# sourceMappingURL=folder-set.js.map

package/dist/m365/spo/commands/group/group-member-add.js

@@ -109,14 +109,14 @@ class SpoGroupMemberAddCommand extends SpoCommand {
                 }
                 else if (args.options.entraGroupNames) {
                     if (this.verbose) {
-                        await logger.logToStderr(`Getting ID of Azure AD group ${trimmedIdentifier}`);
+                        await logger.logToStderr(`Getting ID of Microsoft Entra group ${trimmedIdentifier}`);
                     }
                     const groupId = await entraGroup.getGroupIdByDisplayName(trimmedIdentifier);
                     validUserNames.push(groupId);
                 }
                 else {
                     if (this.verbose) {
-                        await logger.logToStderr(`Getting Azure AD ID for user ${trimmedIdentifier}`);
+                        await logger.logToStderr(`Getting Microsoft Entra ID for user ${trimmedIdentifier}`);
                     }
                     const upn = await entraUser.getUserIdByEmail(trimmedIdentifier);
                     validUserNames.push(upn);

package/dist/m365/spo/commands/group/group-member-remove.js

@@ -122,7 +122,7 @@ class SpoGroupMemberRemoveCommand extends SpoCommand {
             foundGroups = getGroupMemberListOutput.filter((x) => { return x.Title === args.options.entraGroupName && (x.LoginName.indexOf("c:0o.c|federateddirectoryclaimprovider|") === 0 || x.LoginName.indexOf("c:0t.c|tenant|") === 0); });
         }
         if (foundGroups.length === 0) {
-            throw `The Azure AD group ${args.options.entraGroupId || args.options.entraGroupName} is not found in SharePoint group ${args.options.groupId || args.options.groupName}`;
+            throw `The Microsoft Entra group ${args.options.entraGroupId || args.options.entraGroupName} is not found in SharePoint group ${args.options.groupId || args.options.groupName}`;
         }
         return foundGroups[0].Id;
     }

package/dist/m365/spo/commands/site/site-apppermission-add.js

@@ -51,10 +51,10 @@ class SpoSiteAppPermissionAddCommand extends GraphCommand {
         const response = await request.get(appRequestOptions);
         const appItem = response.value[0];
         if (!appItem) {
-            throw "The specified Azure AD app does not exist";
+            throw "The specified Microsoft Entra app does not exist";
         }
         if (response.value.length > 1) {
-            throw `Multiple Azure AD app with displayName ${args.options.appDisplayName} found: ${response.value.map(x => x.appId)}`;
+            throw `Multiple Microsoft Entra apps with displayName ${args.options.appDisplayName} found: ${response.value.map(x => x.appId)}`;
         }
         return {
             appId: appItem.appId,

package/dist/m365/spo/commands/site/site-recyclebinitem-restore.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SpoSiteRecycleBinItemRestoreCommand_instances, _SpoSiteRecycleBinItemRestoreCommand_initOptions, _SpoSiteRecycleBinItemRestoreCommand_initValidators;
+var _SpoSiteRecycleBinItemRestoreCommand_instances, _SpoSiteRecycleBinItemRestoreCommand_initOptions, _SpoSiteRecycleBinItemRestoreCommand_initValidators, _SpoSiteRecycleBinItemRestoreCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
@@ -21,43 +21,73 @@ class SpoSiteRecycleBinItemRestoreCommand extends SpoCommand {
         _SpoSiteRecycleBinItemRestoreCommand_instances.add(this);
         __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoSiteRecycleBinItemRestoreCommand_instances, "m", _SpoSiteRecycleBinItemRestoreCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         if (this.verbose) {
             await logger.logToStderr(`Restoring items from recycle bin at ${args.options.siteUrl}...`);
         }
-        const requestUrl = `${args.options.siteUrl}/_api/site/RecycleBin/RestoreByIds`;
-        const ids = formatting.splitAndTrim(args.options.ids);
-        const idsChunks = [];
-        while (ids.length) {
-            idsChunks.push(ids.splice(0, 20));
-        }
+        const baseUrl = `${args.options.siteUrl}/_api`;
         try {
-            await Promise.all(idsChunks.map((idsChunk) => {
-                const requestOptions = {
-                    url: requestUrl,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata',
-                        'content-type': 'application/json'
-                    },
-                    responseType: 'json',
-                    data: {
-                        ids: idsChunk
-                    }
-                };
-                return request.post(requestOptions);
-            }));
+            if (args.options.ids) {
+                const requestUrl = baseUrl + '/site/RecycleBin/RestoreByIds';
+                const ids = formatting.splitAndTrim(args.options.ids);
+                const idsChunks = [];
+                while (ids.length) {
+                    idsChunks.push(ids.splice(0, 20));
+                }
+                await Promise.all(idsChunks.map((idsChunk) => {
+                    const requestOptions = {
+                        url: requestUrl,
+                        headers: {
+                            'accept': 'application/json;odata=nometadata',
+                            'content-type': 'application/json'
+                        },
+                        responseType: 'json',
+                        data: {
+                            ids: idsChunk
+                        }
+                    };
+                    return request.post(requestOptions);
+                }));
+            }
+            else {
+                if (args.options.allPrimary && args.options.allSecondary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/site/RecycleBin/RestoreAll');
+                }
+                else if (args.options.allPrimary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/web/RecycleBin/RestoreAll');
+                }
+                else if (args.options.allSecondary) {
+                    await this.restoreRecycleBinStage(baseUrl + '/site/GetRecycleBinItems(rowLimit=2000000000,itemState=2)/RestoreAll');
+                }
+            }
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
+    async restoreRecycleBinStage(requestUrl) {
+        const requestOptions = {
+            url: requestUrl,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json'
+            },
+            responseType: 'json'
+        };
+        return request.post(requestOptions);
+    }
 }
 _SpoSiteRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoSiteRecycleBinItemRestoreCommand_initOptions = function _SpoSiteRecycleBinItemRestoreCommand_initOptions() {
     this.options.unshift({
         option: '-u, --siteUrl <siteUrl>'
     }, {
-        option: '-i, --ids <ids>'
+        option: '-i, --ids [ids]'
+    }, {
+        option: '--allPrimary'
+    }, {
+        option: '--allSecondary'
     });
 }, _SpoSiteRecycleBinItemRestoreCommand_initValidators = function _SpoSiteRecycleBinItemRestoreCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -65,14 +95,23 @@ _SpoSiteRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoSiteRecycleB
         if (isValidSharePointUrl !== true) {
             return isValidSharePointUrl;
         }
-        const invalidIds = formatting
-            .splitAndTrim(args.options.ids)
-            .filter(id => !validation.isValidGuid(id));
-        if (invalidIds.length > 0) {
-            return `The following IDs are invalid: ${invalidIds.join(', ')}`;
+        if (args.options.ids) {
+            const invalidIds = formatting
+                .splitAndTrim(args.options.ids)
+                .filter(id => !validation.isValidGuid(id));
+            if (invalidIds.length > 0) {
+                return `The following IDs are invalid: ${invalidIds.join(', ')}`;
+            }
+        }
+        if ((!args.options.ids && !args.options.allPrimary && !args.options.allSecondary)
+            || (args.options.ids && (args.options.allPrimary || args.options.allSecondary))) {
+            return `Option 'ids' cannot be used with 'allPrimary' or 'allSecondary'.`;
         }
         return true;
     });
+}, _SpoSiteRecycleBinItemRestoreCommand_initTypes = function _SpoSiteRecycleBinItemRestoreCommand_initTypes() {
+    this.types.string.push('siteUrl', 'ids');
+    this.types.boolean.push('allPrimary', 'allSecondary');
 };
 export default new SpoSiteRecycleBinItemRestoreCommand();
 //# sourceMappingURL=site-recyclebinitem-restore.js.map

package/dist/m365/spo/commands/tenant/tenant-settings-set.js

@@ -89,7 +89,7 @@ class SpoTenantSettingsSetCommand extends SpoCommand {
                 throw response.ErrorInfo.ErrorMessage;
             }
             if (args.options.EnableAzureADB2BIntegration === true) {
-                await this.warn(logger, 'WARNING: Make sure to also enable the Azure AD one-time passcode authentication preview. If it is not enabled then SharePoint will not use Azure AD B2B even if EnableAzureADB2BIntegration is set to true. Learn more at http://aka.ms/spo-b2b-integration.');
+                await this.warn(logger, 'WARNING: Make sure to also enable the Microsoft Entra one-time passcode authentication preview. If it is not enabled then SharePoint will not use Microsoft Entra B2B even if EnableAzureADB2BIntegration is set to true. Learn more at http://aka.ms/spo-b2b-integration.');
             }
         }
         catch (err) {