@pnp/cli-microsoft365 10.0.0-beta.e925c1c → 10.0.0-beta.fd332f4

package/dist/m365/spo/commands/site/site-admin-list.js

@@ -17,6 +17,9 @@ class SpoSiteAdminListCommand extends SpoCommand {
     get description() {
         return 'Lists all administrators of a specific SharePoint site';
     }
+    defaultProperties() {
+        return ['Id', 'LoginName', 'Title', 'PrincipalTypeString'];
+    }
     constructor() {
         super();
         _SpoSiteAdminListCommand_instances.add(this);
@@ -46,20 +49,16 @@ class SpoSiteAdminListCommand extends SpoCommand {
         const requestOptions = {
             url: `${adminUrl}/_api/SPO.Tenant/GetSiteAdministrators?siteId='${siteId}'`,
             headers: {
-                accept: 'application/json;odata=nometadata',
-                'content-type': 'application/json;charset=utf-8'
-            }
+                accept: 'application/json;odata=nometadata'
+            },
+            responseType: 'json'
         };
         const response = await request.post(requestOptions);
-        const responseContent = JSON.parse(response);
-        const primaryAdminLoginName = await this.getPrimaryAdminLoginNameFromAdmin(adminUrl, siteId);
-        const mappedResult = responseContent.value.map((u) => ({
-            Id: null,
+        const primaryAdminLoginName = await spo.getPrimaryAdminLoginNameAsAdmin(adminUrl, siteId, logger, this.verbose);
+        const mappedResult = response.value.map((u) => ({
             Email: u.email,
             LoginName: u.loginName,
             Title: u.name,
-            PrincipalType: null,
-            PrincipalTypeString: null,
             IsPrimaryAdmin: u.loginName === primaryAdminLoginName
         }));
         await logger.log(mappedResult);
@@ -72,32 +71,19 @@ class SpoSiteAdminListCommand extends SpoCommand {
         }
         return match[1];
     }
-    async getPrimaryAdminLoginNameFromAdmin(adminUrl, siteId) {
-        const requestOptions = {
-            url: `${adminUrl}/_api/SPO.Tenant/sites('${siteId}')?$select=OwnerLoginName`,
-            headers: {
-                accept: 'application/json;odata=nometadata',
-                'content-type': 'application/json;charset=utf-8'
-            }
-        };
-        const response = await request.get(requestOptions);
-        const responseContent = JSON.parse(response);
-        return responseContent.OwnerLoginName;
-    }
     async callAction(logger, args) {
         if (this.verbose) {
             await logger.logToStderr('Retrieving site administrators...');
         }
         const requestOptions = {
             url: `${args.options.siteUrl}/_api/web/siteusers?$filter=IsSiteAdmin eq true`,
-            method: 'GET',
             headers: {
                 'accept': 'application/json;odata=nometadata'
             },
             responseType: 'json'
         };
         const responseContent = await request.get(requestOptions);
-        const primaryOwnerLogin = await this.getPrimaryOwnerLoginFromSite(args.options.siteUrl);
+        const primaryOwnerLogin = await spo.getPrimaryOwnerLoginFromSite(args.options.siteUrl, logger, this.verbose);
         const mappedResult = responseContent.value.map((u) => ({
             Id: u.Id,
             LoginName: u.LoginName,
@@ -109,23 +95,10 @@ class SpoSiteAdminListCommand extends SpoCommand {
         }));
         await logger.log(mappedResult);
     }
-    async getPrimaryOwnerLoginFromSite(siteUrl) {
-        const requestOptions = {
-            url: `${siteUrl}/_api/site/owner`,
-            method: 'GET',
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        const responseContent = await request.get(requestOptions);
-        return responseContent?.LoginName ?? null;
-    }
 }
 _SpoSiteAdminListCommand_instances = new WeakSet(), _SpoSiteAdminListCommand_initTelemetry = function _SpoSiteAdminListCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
-            siteUrl: typeof args.options.siteUrl !== 'undefined',
             asAdmin: !!args.options.asAdmin
         });
     });
@@ -139,6 +112,7 @@ _SpoSiteAdminListCommand_instances = new WeakSet(), _SpoSiteAdminListCommand_ini
     this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.siteUrl));
 }, _SpoSiteAdminListCommand_initTypes = function _SpoSiteAdminListCommand_initTypes() {
     this.types.string.push('siteUrl');
+    this.types.boolean.push('asAdmin');
 };
 export default new SpoSiteAdminListCommand();
 //# sourceMappingURL=site-admin-list.js.map

package/dist/m365/spo/commands/site/site-admin-remove.js

@@ -0,0 +1,194 @@
+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 _SpoSiteAdminRemoveCommand_instances, _SpoSiteAdminRemoveCommand_initTelemetry, _SpoSiteAdminRemoveCommand_initOptions, _SpoSiteAdminRemoveCommand_initValidators, _SpoSiteAdminRemoveCommand_initOptionSets, _SpoSiteAdminRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { spo } from '../../../../utils/spo.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoSiteAdminRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.SITE_ADMIN_REMOVE;
+    }
+    get description() {
+        return 'Removes a user or group as site collection administrator';
+    }
+    constructor() {
+        super();
+        _SpoSiteAdminRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (!args.options.force) {
+                const principalToDelete = args.options.groupId || args.options.groupName ? 'group' : 'user';
+                const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove specified ${principalToDelete} from the site administrators list ${args.options.siteUrl}?` });
+                if (!result) {
+                    return;
+                }
+            }
+            const loginNameToRemove = await this.getCorrectLoginName(args.options);
+            if (args.options.asAdmin) {
+                await this.callActionAsAdmin(logger, args, loginNameToRemove);
+                return;
+            }
+            await this.callAction(logger, args, loginNameToRemove);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async callActionAsAdmin(logger, args, loginNameToRemove) {
+        if (this.verbose) {
+            await logger.logToStderr('Removing site administrator as an administrator...');
+        }
+        const adminUrl = await spo.getSpoAdminUrl(logger, this.debug);
+        const siteId = await this.getSiteId(args.options.siteUrl, logger);
+        const primaryAdminLoginName = await spo.getPrimaryAdminLoginNameAsAdmin(adminUrl, siteId, logger, this.verbose);
+        if (loginNameToRemove === primaryAdminLoginName) {
+            throw 'You cannot remove the primary site collection administrator.';
+        }
+        const existingAdmins = await this.getSiteAdmins(adminUrl, siteId);
+        const adminsToSet = existingAdmins.filter(u => u.loginName.toLowerCase() !== loginNameToRemove.toLowerCase());
+        await this.setSiteAdminsAsAdmin(adminUrl, siteId, adminsToSet);
+    }
+    async getSiteId(siteUrl, logger) {
+        const siteGraphId = await spo.getSiteId(siteUrl, logger, this.verbose);
+        const match = siteGraphId.match(/,([a-f0-9\-]{36}),/i);
+        if (!match) {
+            throw `Site with URL ${siteUrl} not found`;
+        }
+        return match[1];
+    }
+    async getSiteAdmins(adminUrl, siteId) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPO.Tenant/GetSiteAdministrators?siteId='${siteId}'`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            responseType: 'json'
+        };
+        const response = await request.post(requestOptions);
+        return response.value;
+    }
+    async getCorrectLoginName(options) {
+        if (options.userId || options.userName) {
+            const userPrincipalName = options.userName ? options.userName : await entraUser.getUpnByUserId(options.userId);
+            if (userPrincipalName) {
+                return `i:0#.f|membership|${userPrincipalName}`;
+            }
+            throw 'User not found.';
+        }
+        else {
+            const group = options.groupId ? await entraGroup.getGroupById(options.groupId) : await entraGroup.getGroupByDisplayName(options.groupName);
+            //for entra groups, M365 groups have an associated email and security groups don't
+            if (group?.mail) {
+                //M365 group is prefixed with c:0o.c|federateddirectoryclaimprovider
+                return `c:0o.c|federateddirectoryclaimprovider|${group.id}`;
+            }
+            else {
+                //security group is prefixed with c:0t.c|tenant
+                return `c:0t.c|tenant|${group?.id}`;
+            }
+        }
+    }
+    async setSiteAdminsAsAdmin(adminUrl, siteId, admins) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPOInternalUseOnly.Tenant/SetSiteSecondaryAdministrators`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            data: {
+                secondaryAdministratorsFieldsData: {
+                    siteId: siteId,
+                    secondaryAdministratorLoginNames: admins.map(u => u.loginName)
+                }
+            },
+            responseType: 'json'
+        };
+        await request.post(requestOptions);
+    }
+    async callAction(logger, args, loginNameToRemove) {
+        if (this.verbose) {
+            await logger.logToStderr('Removing site administrator...');
+        }
+        const primaryOwnerLogin = await spo.getPrimaryOwnerLoginFromSite(args.options.siteUrl, logger, this.verbose);
+        if (loginNameToRemove === primaryOwnerLogin) {
+            throw 'You cannot remove the primary site collection administrator.';
+        }
+        const requestOptions = {
+            url: `${args.options.siteUrl}/_api/web/siteusers('${formatting.encodeQueryParameter(loginNameToRemove)}')`,
+            headers: {
+                'accept': 'application/json',
+                'X-Http-Method': 'MERGE',
+                'If-Match': '*'
+            },
+            data: { IsSiteAdmin: false },
+            responseType: 'json'
+        };
+        await request.post(requestOptions);
+    }
+}
+_SpoSiteAdminRemoveCommand_instances = new WeakSet(), _SpoSiteAdminRemoveCommand_initTelemetry = function _SpoSiteAdminRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupName: typeof args.options.groupName !== 'undefined',
+            force: !!args.options.force,
+            asAdmin: !!args.options.asAdmin
+        });
+    });
+}, _SpoSiteAdminRemoveCommand_initOptions = function _SpoSiteAdminRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --siteUrl <siteUrl>'
+    }, {
+        option: '--userId [userId]'
+    }, {
+        option: '--userName [userName]'
+    }, {
+        option: '--groupId [groupId]'
+    }, {
+        option: '--groupName [groupName]'
+    }, {
+        option: '--asAdmin'
+    }, {
+        option: '-f, --force'
+    });
+}, _SpoSiteAdminRemoveCommand_initValidators = function _SpoSiteAdminRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId &&
+            !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid GUID`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid userName`;
+        }
+        if (args.options.groupId &&
+            !validation.isValidGuid(args.options.groupId)) {
+            return `${args.options.groupId} is not a valid GUID`;
+        }
+        return validation.isValidSharePointUrl(args.options.siteUrl);
+    });
+}, _SpoSiteAdminRemoveCommand_initOptionSets = function _SpoSiteAdminRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['userId', 'userName', 'groupId', 'groupName'] });
+}, _SpoSiteAdminRemoveCommand_initTypes = function _SpoSiteAdminRemoveCommand_initTypes() {
+    this.types.string.push('siteUrl', 'userId', 'userName', 'groupId', 'groupName');
+    this.types.boolean.push('force', 'asAdmin');
+};
+export default new SpoSiteAdminRemoveCommand();
+//# sourceMappingURL=site-admin-remove.js.map

package/dist/m365/spo/commands/site/site-sharingpermission-set.js

@@ -0,0 +1,68 @@
+import SpoCommand from '../../../base/SpoCommand.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+import { zod } from '../../../../utils/zod.js';
+import commands from '../../commands.js';
+import { validation } from '../../../../utils/validation.js';
+import request from '../../../../request.js';
+const options = globalOptionsZod
+    .extend({
+    siteUrl: zod.alias('u', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint Online site URL.`
+    }))),
+    capability: z.enum(['full', 'limited', 'ownersOnly'])
+})
+    .strict();
+class SpoSiteSharingPermissionSetCommand extends SpoCommand {
+    get name() {
+        return commands.SITE_SHARINGPERMISSION_SET;
+    }
+    get description() {
+        return 'Controls how a site and its components can be shared';
+    }
+    get schema() {
+        return options;
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Updating sharing permissions for site '${args.options.siteUrl}'...`);
+            }
+            const { capability } = args.options;
+            if (this.verbose) {
+                await logger.logToStderr(`Updating site sharing permissions...`);
+            }
+            const requestOptionsWeb = {
+                url: `${args.options.siteUrl}/_api/Web`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    MembersCanShare: capability === 'full' || capability === 'limited'
+                }
+            };
+            await request.patch(requestOptionsWeb);
+            if (this.verbose) {
+                await logger.logToStderr(`Updating associated member group sharing permissions...`);
+            }
+            const requestOptionsMemberGroup = {
+                url: `${args.options.siteUrl}/_api/Web/AssociatedMemberGroup`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    AllowMembersEditMembership: capability === 'full'
+                }
+            };
+            await request.patch(requestOptionsMemberGroup);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new SpoSiteSharingPermissionSetCommand();
+//# sourceMappingURL=site-sharingpermission-set.js.map

package/dist/m365/spo/commands/sitescript/sitescript-get.js

@@ -37,8 +37,9 @@ class SpoSiteScriptGetCommand extends SpoCommand {
                 responseType: 'json'
             };
             const response = await request.post(requestOptions);
-            if (args.options.content === true) {
-                await logger.log(JSON.parse(response.Content));
+            response.Content = JSON.parse(response.Content);
+            if (args.options.content) {
+                await logger.log(response.Content);
                 return;
             }
             await logger.log(response);

package/dist/m365/spo/commands/sitescript/sitescript-list.js

@@ -22,9 +22,7 @@ class SpoSiteScriptListCommand extends SpoCommand {
                 responseType: 'json'
             };
             const res = await request.post(requestOptions);
-            if (res.value && res.value.length > 0) {
-                await logger.log(res.value);
-            }
+            await logger.log(res.value);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);

package/dist/m365/spo/commands/tenant/tenant-site-membership-list.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 _SpoTenantSiteMembershipListCommand_instances, _a, _SpoTenantSiteMembershipListCommand_initTelemetry, _SpoTenantSiteMembershipListCommand_initOptions, _SpoTenantSiteMembershipListCommand_initValidators, _SpoTenantSiteMembershipListCommand_initTypes;
+import { odata } from '../../../../utils/odata.js';
+import { spo } from '../../../../utils/spo.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoTenantSiteMembershipListCommand extends SpoCommand {
+    get name() {
+        return commands.TENANT_SITE_MEMBERSHIP_LIST;
+    }
+    get description() {
+        return `Retrieves information about default site groups' membership`;
+    }
+    defaultProperties() {
+        return ['email', 'name', 'userPrincipalName', 'associatedGroupType'];
+    }
+    constructor() {
+        super();
+        _SpoTenantSiteMembershipListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteMembershipListCommand_instances, "m", _SpoTenantSiteMembershipListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteMembershipListCommand_instances, "m", _SpoTenantSiteMembershipListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteMembershipListCommand_instances, "m", _SpoTenantSiteMembershipListCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteMembershipListCommand_instances, "m", _SpoTenantSiteMembershipListCommand_initTypes).call(this);
+    }
+    ;
+    async commandAction(logger, args) {
+        try {
+            const spoAdminUrl = await spo.getSpoAdminUrl(logger, this.verbose);
+            const roleIds = this.getRoleIds(args.options.role);
+            const tenantSiteProperties = await spo.getSiteAdminPropertiesByUrl(args.options.siteUrl, false, logger, this.verbose);
+            const response = await odata.getAllItems(`${spoAdminUrl}/_api/SPO.Tenant/sites/GetSiteUserGroups?siteId='${tenantSiteProperties.SiteId}'&userGroupIds=[${roleIds}]`);
+            const result = args.options.output === 'json' ? this.mapResult(response, args.options.role) : this.mapListResult(response, args.options.role);
+            await logger.log(result);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    getRoleIds(role) {
+        switch (role?.toLowerCase()) {
+            case 'owner':
+                return '0';
+            case 'member':
+                return '1';
+            case 'visitor':
+                return '2';
+            default:
+                return '0,1,2';
+        }
+    }
+    mapResult(response, role) {
+        switch (role?.toLowerCase()) {
+            case 'owner':
+                return { AssociatedOwnerGroup: response[0].userGroup };
+            case 'member':
+                return { AssociatedMemberGroup: response[0].userGroup };
+            case 'visitor':
+                return { AssociatedVisitorGroup: response[0].userGroup };
+            default:
+                return {
+                    AssociatedOwnerGroup: response[0].userGroup,
+                    AssociatedMemberGroup: response[1].userGroup,
+                    AssociatedVisitorGroup: response[2].userGroup
+                };
+        }
+    }
+    mapListResult(response, role) {
+        const mapGroup = (groupIndex, groupType) => response[groupIndex].userGroup.map(user => ({
+            ...user,
+            associatedGroupType: groupType
+        }));
+        switch (role?.toLowerCase()) {
+            case 'owner':
+                return mapGroup(0, 'Owner');
+            case 'member':
+                return mapGroup(0, 'Member');
+            case 'visitor':
+                return mapGroup(0, 'Visitor');
+            default:
+                return [
+                    ...mapGroup(0, 'Owner'),
+                    ...mapGroup(1, 'Member'),
+                    ...mapGroup(2, 'Visitor')
+                ];
+        }
+    }
+}
+_a = SpoTenantSiteMembershipListCommand, _SpoTenantSiteMembershipListCommand_instances = new WeakSet(), _SpoTenantSiteMembershipListCommand_initTelemetry = function _SpoTenantSiteMembershipListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            role: typeof args.options.role !== 'undefined'
+        });
+    });
+}, _SpoTenantSiteMembershipListCommand_initOptions = function _SpoTenantSiteMembershipListCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --siteUrl <siteUrl>'
+    }, {
+        option: '-r, --role [role]',
+        autocomplete: _a.RoleNames
+    });
+}, _SpoTenantSiteMembershipListCommand_initValidators = function _SpoTenantSiteMembershipListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.role && !_a.RoleNames.some(roleName => roleName.toLocaleLowerCase() === args.options.role.toLocaleLowerCase())) {
+            return `'${args.options.role}' is not a valid value for option 'role'. Valid values are: ${_a.RoleNames.join(', ')}`;
+        }
+        return validation.isValidSharePointUrl(args.options.siteUrl);
+    });
+}, _SpoTenantSiteMembershipListCommand_initTypes = function _SpoTenantSiteMembershipListCommand_initTypes() {
+    this.types.string.push('role', 'siteUrl');
+};
+SpoTenantSiteMembershipListCommand.RoleNames = ['Owner', 'Member', 'Visitor'];
+export default new SpoTenantSiteMembershipListCommand();
+//# sourceMappingURL=tenant-site-membership-list.js.map

package/dist/m365/spo/commands/{site/site-rename.js → tenant/tenant-site-rename.js}

@@ -3,25 +3,26 @@ 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 _SpoSiteRenameCommand_instances, _SpoSiteRenameCommand_initTelemetry, _SpoSiteRenameCommand_initOptions, _SpoSiteRenameCommand_initValidators;
+var _SpoTenantSiteRenameCommand_instances, _SpoTenantSiteRenameCommand_initTelemetry, _SpoTenantSiteRenameCommand_initOptions, _SpoTenantSiteRenameCommand_initValidators;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { spo } from '../../../../utils/spo.js';
+import { timersUtil } from '../../../../utils/timersUtil.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
-class SpoSiteRenameCommand extends SpoCommand {
+class SpoTenantSiteRenameCommand extends SpoCommand {
     get name() {
-        return commands.SITE_RENAME;
+        return commands.TENANT_SITE_RENAME;
     }
     get description() {
         return 'Renames the URL and title of a site collection';
     }
     constructor() {
         super();
-        _SpoSiteRenameCommand_instances.add(this);
-        __classPrivateFieldGet(this, _SpoSiteRenameCommand_instances, "m", _SpoSiteRenameCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _SpoSiteRenameCommand_instances, "m", _SpoSiteRenameCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _SpoSiteRenameCommand_instances, "m", _SpoSiteRenameCommand_initValidators).call(this);
+        _SpoTenantSiteRenameCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteRenameCommand_instances, "m", _SpoTenantSiteRenameCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteRenameCommand_instances, "m", _SpoTenantSiteRenameCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoTenantSiteRenameCommand_instances, "m", _SpoTenantSiteRenameCommand_initValidators).call(this);
     }
     async commandAction(logger, args) {
         try {
@@ -40,24 +41,23 @@ class SpoSiteRenameCommand extends SpoCommand {
                 optionsBitmask = optionsBitmask | 16;
             }
             const requestOptions = {
-                "SourceSiteUrl": options.url,
-                "TargetSiteUrl": options.newUrl,
-                "TargetSiteTitle": options.newTitle || null,
-                "Option": optionsBitmask,
-                "Reserve": null,
-                "SkipGestures": null,
-                "OperationId": "00000000-0000-0000-0000-000000000000"
-            };
-            const postData = {
                 url: `${spoAdminUrl}/_api/SiteRenameJobs?api-version=1.4.7`,
                 headers: {
                     'X-RequestDigest': this.context.FormDigestValue,
                     'Content-Type': 'application/json'
                 },
                 responseType: 'json',
-                data: requestOptions
+                data: {
+                    SourceSiteUrl: options.url,
+                    TargetSiteUrl: options.newUrl,
+                    TargetSiteTitle: options.newTitle || null,
+                    Option: optionsBitmask,
+                    Reserve: null,
+                    SkipGestures: null,
+                    OperationId: '00000000-0000-0000-0000-000000000000'
+                }
             };
-            const res = await request.post(postData);
+            const res = await request.post(requestOptions);
             if (options.verbose) {
                 await logger.logToStderr(res);
             }
@@ -92,23 +92,20 @@ class SpoSiteRenameCommand extends SpoCommand {
         if (this.operationData.JobState === "Success") {
             return;
         }
-        await this.sleep(SpoSiteRenameCommand.checkIntervalInMs);
+        await timersUtil.setTimeout(SpoTenantSiteRenameCommand.checkIntervalInMs);
         await command.waitForRenameCompletion(command, isVerbose, spoAdminUrl, siteUrl, iteration);
     }
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
 }
-_SpoSiteRenameCommand_instances = new WeakSet(), _SpoSiteRenameCommand_initTelemetry = function _SpoSiteRenameCommand_initTelemetry() {
+_SpoTenantSiteRenameCommand_instances = new WeakSet(), _SpoTenantSiteRenameCommand_initTelemetry = function _SpoTenantSiteRenameCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
-            newTitle: args.options.newTitle ? true : false,
-            suppressMarketplaceAppCheck: args.options.suppressMarketplaceAppCheck,
-            suppressWorkflow2013Check: args.options.suppressWorkflow2013Check,
-            wait: args.options.wait
+            newTitle: typeof args.options.newTitle !== 'undefined',
+            suppressMarketplaceAppCheck: !!args.options.suppressMarketplaceAppCheck,
+            suppressWorkflow2013Check: !!args.options.suppressWorkflow2013Check,
+            wait: !!args.options.wait
         });
     });
-}, _SpoSiteRenameCommand_initOptions = function _SpoSiteRenameCommand_initOptions() {
+}, _SpoTenantSiteRenameCommand_initOptions = function _SpoTenantSiteRenameCommand_initOptions() {
     this.options.unshift({
         option: '-u, --url <url>'
     }, {
@@ -122,7 +119,7 @@ _SpoSiteRenameCommand_instances = new WeakSet(), _SpoSiteRenameCommand_initTelem
     }, {
         option: '--wait'
     });
-}, _SpoSiteRenameCommand_initValidators = function _SpoSiteRenameCommand_initValidators() {
+}, _SpoTenantSiteRenameCommand_initValidators = function _SpoTenantSiteRenameCommand_initValidators() {
     this.validators.push(async (args) => {
         if (args.options.url.toLowerCase() === args.options.newUrl.toLowerCase()) {
             return 'The new URL cannot be the same as the target URL.';
@@ -130,6 +127,6 @@ _SpoSiteRenameCommand_instances = new WeakSet(), _SpoSiteRenameCommand_initTelem
         return true;
     });
 };
-SpoSiteRenameCommand.checkIntervalInMs = 5000;
-export default new SpoSiteRenameCommand();
-//# sourceMappingURL=site-rename.js.map
+SpoTenantSiteRenameCommand.checkIntervalInMs = 5000;
+export default new SpoTenantSiteRenameCommand();
+//# sourceMappingURL=tenant-site-rename.js.map

package/dist/m365/spo/commands/theme/theme-list.js

@@ -26,7 +26,7 @@ class SpoThemeListCommand extends SpoCommand {
                 responseType: 'json'
             };
             const rawRes = await request.post(requestOptions);
-            await logger.log(rawRes.themePreviews);
+            await logger.log(rawRes.themePreviews || []);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);