@pnp/cli-microsoft365 10.9.0 → 10.10.0-beta.1bb5ba0

package/dist/m365/spo/commands/folder/folder-sharinglink-get.js

@@ -35,7 +35,7 @@ class SpoFolderSharingLinkGetCommand extends SpoCommand {
             const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId);
             const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
             const folderUrl = new URL(absoluteFolderUrl);
-            const siteId = await spo.getSiteId(args.options.webUrl);
+            const siteId = await spo.getSiteIdByMSGraph(args.options.webUrl);
             const drive = await driveItem.getDriveByUrl(siteId, folderUrl);
             const itemId = await driveItem.getDriveItemId(drive, folderUrl);
             const requestUrl = `https://graph.microsoft.com/v1.0/drives/${drive.id}/items/${itemId}/permissions/${args.options.id}`;

package/dist/m365/spo/commands/folder/folder-sharinglink-list.js

@@ -40,7 +40,7 @@ class SpoFolderSharingLinkListCommand extends SpoCommand {
             const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
             const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
             const folderUrl = new URL(absoluteFolderUrl);
-            const siteId = await spo.getSiteId(args.options.webUrl);
+            const siteId = await spo.getSiteIdByMSGraph(args.options.webUrl);
             const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
             const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
             let requestUrl = `https://graph.microsoft.com/v1.0/drives/${driveDetails.id}/items/${itemId}/permissions?$filter=Link ne null`;

package/dist/m365/spo/commands/folder/folder-sharinglink-remove.js

@@ -37,7 +37,7 @@ class SpoFolderSharingLinkRemoveCommand extends SpoCommand {
                 const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
                 const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
                 const folderUrl = new URL(absoluteFolderUrl);
-                const siteId = await spo.getSiteId(args.options.webUrl);
+                const siteId = await spo.getSiteIdByMSGraph(args.options.webUrl);
                 const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
                 const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
                 const requestOptions = {

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

@@ -35,7 +35,7 @@ class SpoFolderSharingLinkSetCommand extends SpoCommand {
             const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId, logger, args.options.verbose);
             const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
             const folderUrl = new URL(absoluteFolderUrl);
-            const siteId = await spo.getSiteId(args.options.webUrl);
+            const siteId = await spo.getSiteIdByMSGraph(args.options.webUrl);
             const driveDetails = await drive.getDriveByUrl(siteId, folderUrl, logger, args.options.verbose);
             const itemId = await drive.getDriveItemId(driveDetails, folderUrl, logger, args.options.verbose);
             const requestOptions = {

package/dist/m365/spo/commands/list/list-view-add.js

@@ -1,53 +1,126 @@
-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 _SpoListViewAddCommand_instances, _SpoListViewAddCommand_initTelemetry, _SpoListViewAddCommand_initOptions, _SpoListViewAddCommand_initValidators, _SpoListViewAddCommand_initOptionSets;
+import { globalOptionsZod } from '../../../../Command.js';
 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 { z } from 'zod';
+import { zod } from '../../../../utils/zod.js';
+const options = globalOptionsZod
+    .extend({
+    webUrl: zod.alias('u', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        message: 'webUrl is not a valid SharePoint site URL.'
+    })),
+    listId: z.string()
+        .refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional(),
+    listTitle: z.string().optional(),
+    listUrl: z.string().optional(),
+    title: z.string().min(1, 'Cannot be empty.'),
+    fields: z.string().optional(),
+    viewQuery: z.string().optional(),
+    personal: z.boolean().optional(),
+    default: z.boolean().optional(),
+    paged: z.boolean().optional(),
+    rowLimit: z.number().int().positive().optional(),
+    customFormatter: z.string()
+        .refine(formatter => {
+        try {
+            JSON.parse(formatter);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, {
+        message: 'Custom formatter must be a valid JSON string.'
+    })
+        .optional(),
+    type: z.enum(['list', 'calendar', 'gallery', 'kanban']).optional(),
+    calendarStartDateField: z.string().min(1, 'Cannot be empty.').optional(),
+    calendarEndDateField: z.string().min(1, 'Cannot be empty.').optional(),
+    calendarTitleField: z.string().min(1, 'Cannot be empty.').optional(),
+    calendarSubTitleField: z.string().min(1, 'Cannot be empty.').optional(),
+    calendarDefaultLayout: z.enum(['month', 'week', 'workWeek', 'day']).optional(),
+    kanbanBucketField: z.string().min(1, 'Cannot be empty.').optional()
+})
+    .strict();
 class SpoListViewAddCommand extends SpoCommand {
     get name() {
         return commands.LIST_VIEW_ADD;
     }
     get description() {
-        return 'Adds a new view to a SharePoint list.';
+        return 'Adds a new view to a SharePoint list';
     }
-    constructor() {
-        super();
-        _SpoListViewAddCommand_instances.add(this);
-        __classPrivateFieldGet(this, _SpoListViewAddCommand_instances, "m", _SpoListViewAddCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _SpoListViewAddCommand_instances, "m", _SpoListViewAddCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _SpoListViewAddCommand_instances, "m", _SpoListViewAddCommand_initValidators).call(this);
-        __classPrivateFieldGet(this, _SpoListViewAddCommand_instances, "m", _SpoListViewAddCommand_initOptionSets).call(this);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine((options) => [options.listId, options.listTitle, options.listUrl].filter(o => o !== undefined).length === 1, {
+            message: 'Use one of the following options: listId, listTitle, or listUrl.'
+        })
+            .refine((options) => !options.personal || !options.default, {
+            message: 'Default view cannot be a personal view.'
+        })
+            .refine((options) => options.type !== 'calendar' || [options.calendarStartDateField, options.calendarEndDateField, options.calendarTitleField].filter(o => o === undefined).length === 0, {
+            message: 'When type is calendar, do specify calendarStartDateField, calendarEndDateField, and calendarTitleField.'
+        })
+            .refine((options) => options.type === 'calendar' || [options.calendarStartDateField, options.calendarEndDateField, options.calendarTitleField].filter(o => o === undefined).length === 3, {
+            message: 'When type is not calendar, do not specify calendarStartDateField, calendarEndDateField, and calendarTitleField.'
+        })
+            .refine((options) => options.type !== 'kanban' || options.kanbanBucketField !== undefined, {
+            message: 'When type is kanban, do specify kanbanBucketField.'
+        })
+            .refine((options) => options.type === 'kanban' || options.kanbanBucketField === undefined, {
+            message: 'When type is not kanban, do not specify kanbanBucketField.'
+        })
+            .refine((options) => options.type === 'calendar' || options.fields !== undefined, {
+            message: 'When type is not calendar, do specify fields.'
+        });
     }
     async commandAction(logger, args) {
-        const requestOptions = {
-            url: this.getRestUrl(args.options),
-            headers: {
-                'content-type': 'application/json;odata=verbose',
-                accept: 'application/json;odata=nometadata'
-            },
-            responseType: 'json',
-            data: {
-                parameters: {
-                    Title: args.options.title,
-                    ViewFields: {
-                        results: args.options.fields.split(',')
-                    },
-                    Query: args.options.viewQuery,
-                    PersonalView: !!args.options.personal,
-                    SetAsDefaultView: !!args.options.default,
-                    Paged: !!args.options.paged,
-                    RowLimit: args.options.rowLimit ? +args.options.rowLimit : 30
-                }
-            }
-        };
         try {
+            if (this.verbose) {
+                await logger.logToStderr(`Adding view '${args.options.title}' to list...`);
+            }
+            let apiUrl = `${args.options.webUrl}/_api/web/`;
+            if (args.options.listId) {
+                apiUrl += `lists(guid'${formatting.encodeQueryParameter(args.options.listId)}')`;
+            }
+            else if (args.options.listTitle) {
+                apiUrl += `lists/getByTitle('${formatting.encodeQueryParameter(args.options.listTitle)}')`;
+            }
+            else if (args.options.listUrl) {
+                apiUrl += `GetList('${formatting.encodeQueryParameter(urlUtil.getServerRelativePath(args.options.webUrl, args.options.listUrl))}')`;
+            }
+            apiUrl += '/views/add';
+            const requestOptions = {
+                url: apiUrl,
+                headers: {
+                    'content-type': 'application/json;odata=verbose',
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    parameters: {
+                        Title: args.options.title,
+                        ViewFields: {
+                            results: args.options.fields?.split(',').map(f => f.trim()) ?? []
+                        },
+                        Query: args.options.viewQuery,
+                        PersonalView: !!args.options.personal,
+                        SetAsDefaultView: !!args.options.default,
+                        Paged: !!args.options.paged,
+                        RowLimit: args.options.rowLimit ?? 30,
+                        CustomFormatter: args.options.customFormatter
+                    }
+                }
+            };
+            this.setViewTypeSpecificParameters(args.options, requestOptions.data.parameters);
             const result = await request.post(requestOptions);
             await logger.log(result);
         }
@@ -55,62 +128,42 @@ class SpoListViewAddCommand extends SpoCommand {
             this.handleRejectedODataJsonPromise(err);
         }
     }
-    getRestUrl(options) {
-        let result = `${options.webUrl}/_api/web/`;
-        if (options.listId) {
-            result += `lists(guid'${formatting.encodeQueryParameter(options.listId)}')`;
-        }
-        else if (options.listTitle) {
-            result += `lists/getByTitle('${formatting.encodeQueryParameter(options.listTitle)}')`;
-        }
-        else if (options.listUrl) {
-            result += `GetList('${formatting.encodeQueryParameter(urlUtil.getServerRelativePath(options.webUrl, options.listUrl))}')`;
-        }
-        result += '/views/add';
-        return result;
-    }
-}
-_SpoListViewAddCommand_instances = new WeakSet(), _SpoListViewAddCommand_initTelemetry = function _SpoListViewAddCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            listId: typeof args.options.listId !== 'undefined',
-            listTitle: typeof args.options.listTitle !== 'undefined',
-            listUrl: typeof args.options.listUrl !== 'undefined',
-            title: typeof args.options.title !== 'undefined',
-            viewQuery: typeof args.options.viewQuery !== 'undefined',
-            personal: !!args.options.personal,
-            default: !!args.options.default,
-            orderedView: !!args.options.orderedView,
-            paged: !!args.options.paged,
-            rowLimit: typeof args.options.rowLimit !== 'undefined'
-        });
-    });
-}, _SpoListViewAddCommand_initOptions = function _SpoListViewAddCommand_initOptions() {
-    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--listId [listId]' }, { option: '--listTitle [listTitle]' }, { option: '--listUrl [listUrl]' }, { option: '--title <title>' }, { option: '--fields <fields>' }, { option: '--viewQuery [viewQuery]' }, { option: '--personal' }, { option: '--default' }, { option: '--paged' }, { option: '--rowLimit [rowLimit]' });
-}, _SpoListViewAddCommand_initValidators = function _SpoListViewAddCommand_initValidators() {
-    this.validators.push(async (args) => {
-        const webUrlValidation = validation.isValidSharePointUrl(args.options.webUrl);
-        if (webUrlValidation !== true) {
-            return webUrlValidation;
+    setViewTypeSpecificParameters(options, requestBody) {
+        if (options.type === 'calendar') {
+            const defaultView = options.calendarDefaultLayout ?? 'month';
+            const titleField = options.calendarTitleField;
+            const subTitleField = options.calendarSubTitleField ?? '';
+            // Following fields are required for calendar view, order is important
+            const viewFields = [options.calendarStartDateField, options.calendarEndDateField, titleField, subTitleField].filter(field => field !== '');
+            // Add any additional fields specified by the user
+            const extraViewFields = requestBody.ViewFields.results.filter((field) => !viewFields.includes(field.trim()));
+            viewFields.push(...extraViewFields);
+            requestBody.CalendarViewStyles = `<CalendarViewStyle Title="Day" Type="day" Template="CalendarViewdayChrome" Sequence="1" Default="${String(defaultView === 'day').toUpperCase()}" /><CalendarViewStyle Title="Week" Type="week" Template="CalendarViewweekChrome" Sequence="2" Default="${String(defaultView === 'week').toUpperCase()}" /><CalendarViewStyle Title="Month" Type="month" Template="CalendarViewmonthChrome" Sequence="3" Default="${String(defaultView === 'month').toUpperCase()}" /><CalendarViewStyle Title="Work week" Type="workweek" Template="CalendarViewweekChrome" Sequence="4" Default="${String(defaultView === 'workWeek').toUpperCase()}" />`;
+            requestBody.Query = `<Where><DateRangesOverlap><FieldRef Name='${options.calendarStartDateField}' /><FieldRef Name='${options.calendarEndDateField}' /><Value Type='DateTime'><Month /></Value></DateRangesOverlap></Where>`;
+            requestBody.ViewData = `<FieldRef Name="${titleField}" Type="CalendarMonthTitle" /><FieldRef Name="${titleField}" Type="CalendarWeekTitle" /><FieldRef Name="${subTitleField}" Type="CalendarWeekLocation" /><FieldRef Name="${titleField}" Type="CalendarDayTitle" /><FieldRef Name="${subTitleField}" Type="CalendarDayLocation" />`;
+            requestBody.ViewFields.results = viewFields;
+            requestBody.ViewType2 = 'MODERNCALENDAR';
+            return;
         }
-        if (args.options.listId && !validation.isValidGuid(args.options.listId)) {
-            return `${args.options.listId} in option listId is not a valid GUID`;
+        if (options.type === 'gallery') {
+            requestBody.ViewType2 = 'TILES';
+            return;
         }
-        if (args.options.rowLimit !== undefined) {
-            if (isNaN(args.options.rowLimit)) {
-                return `${args.options.rowLimit} is not a number`;
+        if (options.type === 'kanban') {
+            // Add the bucket field to the view fields if it is not already included
+            const viewFields = requestBody.ViewFields.results;
+            if (!viewFields.includes(options.kanbanBucketField)) {
+                viewFields.push(options.kanbanBucketField);
             }
-            if (+args.options.rowLimit <= 0) {
-                return 'rowLimit option must be greater than 0.';
+            if (!options.customFormatter) {
+                requestBody.CustomFormatter = '{}';
             }
+            requestBody.ViewData = `<FieldRef Name="${options.kanbanBucketField}" Type="KanbanPivotColumn" />`;
+            requestBody.ViewType2 = 'KANBAN';
+            return;
         }
-        if (args.options.personal && args.options.default) {
-            return 'Default view cannot be a personal view.';
-        }
-        return true;
-    });
-}, _SpoListViewAddCommand_initOptionSets = function _SpoListViewAddCommand_initOptionSets() {
-    this.optionSets.push({ options: ['listId', 'listTitle', 'listUrl'] });
-};
+    }
+    ;
+}
 export default new SpoListViewAddCommand();
 //# sourceMappingURL=list-view-add.js.map

package/dist/m365/spo/commands/listitem/listitem-batch-set.js

@@ -10,7 +10,6 @@ import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
 import { spo } from '../../../../utils/spo.js';
-import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
@@ -41,7 +40,9 @@ class SpoListItemBatchSetCommand extends SpoCommand {
             if (!jsonContent[0].hasOwnProperty(idColumn)) {
                 throw `The specified value for idColumn does not exist in the array. Specified idColumn is '${args.options.idColumn || 'ID'}'. Please specify the correct value.`;
             }
-            const listId = await this.getListId(args.options, logger);
+            const listId = args.options.listId ?
+                args.options.listId :
+                await spo.getListId(args.options.webUrl, args.options.listTitle, args.options.listUrl, logger, this.verbose);
             const fields = await this.getListFields(args.options, listId, jsonContent, idColumn, logger);
             const userFields = fields.filter(field => field.TypeAsString === 'UserMulti' || field.TypeAsString === 'User');
             const resolvedUsers = await this.getUsersFromCsv(args.options.webUrl, jsonContent, userFields);
@@ -151,31 +152,6 @@ class SpoListItemBatchSetCommand extends SpoCommand {
         }
         return fields;
     }
-    async getListId(options, logger) {
-        if (options.listId) {
-            return options.listId;
-        }
-        if (this.verbose) {
-            await logger.logToStderr('Retrieving list id');
-        }
-        let listUrl = `${options.webUrl}/_api/web`;
-        if (options.listTitle) {
-            listUrl += `/lists/getByTitle('${formatting.encodeQueryParameter(options.listTitle)}')`;
-        }
-        else {
-            const listServerRelativeUrl = urlUtil.getServerRelativePath(options.webUrl, options.listUrl);
-            listUrl += `/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
-        }
-        const requestOptions = {
-            url: `${listUrl}?$select=Id`,
-            headers: {
-                'accept': 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        const listResult = await request.get(requestOptions);
-        return listResult.Id;
-    }
     async getUsersFromCsv(webUrl, jsonContent, userFields) {
         if (userFields.length === 0) {
             return [];

package/dist/m365/spo/commands/page/Page.js

@@ -25,7 +25,7 @@ export class Page {
         }
         return ClientSidePage.fromHtml(res.ListItemAllFields.CanvasContent1);
     }
-    static async checkout(name, webUrl, logger, debug, verbose) {
+    static async checkout(name, webUrl, logger, verbose) {
         if (verbose) {
             await logger.log(`Checking out ${name} page...`);
         }
@@ -77,6 +77,21 @@ export class Page {
             columns: section.columns.map(column => this.getColumnsInformation(column, isJSONOutput))
         };
     }
+    /**
+     * Publish a modern page in SharePoint Online
+     * @param webUrl Absolute URL of the SharePoint site where the page is located
+     * @param pageName List relative url of the page to publish
+     */
+    static async publishPage(webUrl, pageName) {
+        const filePath = `${urlUtil.getServerRelativeSiteUrl(webUrl)}/SitePages/${pageName}`;
+        const requestOptions = {
+            url: `${webUrl}/_api/web/GetFileByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(filePath)}')/Publish()`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            }
+        };
+        await request.post(requestOptions);
+    }
     static getPageNameWithExtension(name) {
         let pageName = name;
         if (pageName.indexOf('.aspx') < 0) {

package/dist/m365/spo/commands/page/clientsidepages.js

@@ -30,6 +30,10 @@ export var CanvasSectionTemplate;
     /// Vertical
     /// </summary>
     CanvasSectionTemplate[CanvasSectionTemplate["Vertical"] = 6] = "Vertical";
+    /// <summary>
+    /// Flexible
+    /// </summary>
+    CanvasSectionTemplate[CanvasSectionTemplate["Flexible"] = 7] = "Flexible";
 })(CanvasSectionTemplate || (CanvasSectionTemplate = {}));
 /**
  * Section background shading

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

@@ -63,7 +63,7 @@ class SpoPageAddCommand extends SpoCommand {
             itemId = template.UniqueId;
             const file = await spo.getFileAsListItemByUrl(args.options.webUrl, serverRelativeFileUrl, logger, this.verbose);
             const listItemId = file.Id;
-            const pageProps = await Page.checkout(pageName, args.options.webUrl, logger, this.debug, this.verbose);
+            const pageProps = await Page.checkout(pageName, args.options.webUrl, logger, this.verbose);
             if (pageProps) {
                 pageId = pageProps.Id;
                 bannerImageUrl = pageProps.BannerImageUrl;

package/dist/m365/spo/commands/page/page-clientsidewebpart-add.js

@@ -11,6 +11,7 @@ import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
 import { StandardWebPartUtils } from '../../StandardWebPartTypes.js';
+import { Page } from './Page.js';
 class SpoPageClientSideWebPartAddCommand extends SpoCommand {
     get name() {
         return commands.PAGE_CLIENTSIDEWEBPART_ADD;
@@ -52,14 +53,7 @@ class SpoPageClientSideWebPartAddCommand extends SpoCommand {
             };
             let page = await request.get(requestOptions);
             if (!page.IsPageCheckedOutToCurrentUser) {
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/sitepages/pages/GetByUrl('sitepages/${formatting.encodeQueryParameter(pageFullName)}')/checkoutpage`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    responseType: 'json'
-                };
-                page = await request.post(requestOptions);
+                page = await Page.checkout(pageFullName, args.options.webUrl, logger, this.verbose);
             }
             if (page) {
                 layoutWebpartsContent = page.LayoutWebpartsContent;

package/dist/m365/spo/commands/page/page-control-remove.js

@@ -0,0 +1,99 @@
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+import commands from '../../commands.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import { zod } from '../../../../utils/zod.js';
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { Page } from './Page.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+const options = globalOptionsZod
+    .extend({
+    webUrl: zod.alias('u', z.string())
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint URL.`
+    })),
+    pageName: zod.alias('n', z.string()),
+    id: zod.alias('i', z.string())
+        .refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })),
+    draft: z.boolean().optional(),
+    force: zod.alias('f', z.boolean().optional())
+})
+    .strict();
+class SpoPageControlRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.PAGE_CONTROL_REMOVE;
+    }
+    get description() {
+        return 'Removes a control from a modern page';
+    }
+    get schema() {
+        return options;
+    }
+    async commandAction(logger, args) {
+        if (!args.options.force) {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to delete control '${args.options.id}' on page '${args.options.pageName}'?` });
+            if (!result) {
+                return;
+            }
+        }
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Getting page properties for page '${args.options.pageName}'...`);
+            }
+            const pageName = urlUtil.removeLeadingSlashes(args.options.pageName.toLowerCase().endsWith('.aspx') ? args.options.pageName : `${args.options.pageName}.aspx`);
+            let requestOptions = {
+                url: `${args.options.webUrl}/_api/SitePages/Pages/GetByUrl('SitePages/${formatting.encodeQueryParameter(pageName)}')?$select=CanvasContent1`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json'
+            };
+            const pageProps = await request.get(requestOptions);
+            if (!pageProps.CanvasContent1) {
+                throw `Page '${pageName}' doesn't contain canvas control '${args.options.id}'.`;
+            }
+            const pageControls = JSON.parse(pageProps.CanvasContent1);
+            const hasControl = pageControls.some(control => control.id?.toLowerCase() === args.options.id.toLowerCase());
+            if (!hasControl) {
+                throw `Control with ID '${args.options.id}' was not found on page '${pageName}'.`;
+            }
+            if (this.verbose) {
+                await logger.logToStderr('Checking out page...');
+            }
+            const page = await Page.checkout(pageName, args.options.webUrl, logger, this.verbose);
+            const canvasContent = JSON.parse(page.CanvasContent1);
+            if (this.verbose) {
+                await logger.logToStderr(`Removing control with ID '${args.options.id}' from page...`);
+            }
+            const pageContent = canvasContent.filter(control => !control.id || control.id.toLowerCase() !== args.options.id.toLowerCase());
+            requestOptions = {
+                url: `${args.options.webUrl}/_api/SitePages/Pages/GetByUrl('SitePages/${formatting.encodeQueryParameter(pageName)}')/SavePageAsDraft`,
+                headers: {
+                    'content-type': 'application/json;odata=nometadata',
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    CanvasContent1: JSON.stringify(pageContent)
+                }
+            };
+            await request.patch(requestOptions);
+            if (!args.options.draft) {
+                if (this.verbose) {
+                    await logger.logToStderr(`Republishing page...`);
+                }
+                await Page.publishPage(args.options.webUrl, pageName);
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new SpoPageControlRemoveCommand();
+//# sourceMappingURL=page-control-remove.js.map

package/dist/m365/spo/commands/page/page-control-set.js

@@ -50,7 +50,7 @@ class SpoPageControlSetCommand extends SpoCommand {
                 await logger.logToStderr(`Control with ID ${args.options.id} found on the page`);
             }
             // Check out the page
-            const page = await Page.checkout(pageName, args.options.webUrl, logger, this.debug, this.verbose);
+            const page = await Page.checkout(pageName, args.options.webUrl, logger, this.verbose);
             // Update the web part data
             const canvasContent = JSON.parse(page.CanvasContent1);
             if (this.debug) {

package/dist/m365/spo/commands/page/page-header-set.js

@@ -6,9 +6,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _SpoPageHeaderSetCommand_instances, _SpoPageHeaderSetCommand_initTelemetry, _SpoPageHeaderSetCommand_initOptions, _SpoPageHeaderSetCommand_initValidators;
 import request from '../../../../request.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';
+import { Page } from './Page.js';
 const BannerWebPartId = 'cbe7b0a9-3504-44dd-a3a3-0e5cacd07788';
 class SpoPageHeaderSetCommand extends SpoCommand {
     get name() {
@@ -148,14 +150,7 @@ class SpoPageHeaderSetCommand extends SpoCommand {
                 pageData = await request.get(requestOptions);
             }
             else {
-                const requestOptions = {
-                    url: `${args.options.webUrl}/_api/sitepages/pages/GetByUrl('sitepages/${formatting.encodeQueryParameter(pageFullName)}')/checkoutpage`,
-                    headers: {
-                        'accept': 'application/json;odata=nometadata'
-                    },
-                    responseType: 'json'
-                };
-                pageData = await request.post(requestOptions);
+                pageData = await Page.checkout(pageFullName, args.options.webUrl, logger, this.verbose);
             }
             switch (args.options.type) {
                 case 'None':
@@ -220,23 +215,23 @@ class SpoPageHeaderSetCommand extends SpoCommand {
                 }
                 else {
                     const res = await Promise.all([
-                        this.getSiteId(args.options.webUrl, this.verbose, logger),
-                        this.getWebId(args.options.webUrl, this.verbose, logger),
+                        spo.getSiteIdBySPApi(args.options.webUrl, logger, this.verbose),
+                        spo.getWebId(args.options.webUrl, logger, this.verbose),
                         this.getImageInfo(args.options.webUrl, args.options.imageUrl, this.verbose, logger)
                     ]);
                     header.serverProcessedContent.customMetadata = {
                         imageSource: {
-                            siteId: res[0].Id,
-                            webId: res[1].Id,
+                            siteId: res[0],
+                            webId: res[1],
                             listId: res[2].ListId,
                             uniqueId: res[2].UniqueId
                         }
                     };
                     const properties = header.properties;
                     properties.listId = res[2].ListId;
-                    properties.siteId = res[0].Id;
+                    properties.siteId = res[0];
                     properties.uniqueId = res[2].UniqueId;
-                    properties.webId = res[1].Id;
+                    properties.webId = res[1];
                     header.properties = properties;
                 }
             }
@@ -306,32 +301,6 @@ class SpoPageHeaderSetCommand extends SpoCommand {
             this.handleRejectedODataJsonPromise(err);
         }
     }
-    async getSiteId(siteUrl, verbose, logger) {
-        if (verbose) {
-            await logger.logToStderr(`Retrieving information about the site collection...`);
-        }
-        const requestOptions = {
-            url: `${siteUrl}/_api/site?$select=Id`,
-            headers: {
-                accept: 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        return request.get(requestOptions);
-    }
-    async getWebId(siteUrl, verbose, logger) {
-        if (verbose) {
-            await logger.logToStderr(`Retrieving information about the site...`);
-        }
-        const requestOptions = {
-            url: `${siteUrl}/_api/web?$select=Id`,
-            headers: {
-                accept: 'application/json;odata=nometadata'
-            },
-            responseType: 'json'
-        };
-        return request.get(requestOptions);
-    }
     async getImageInfo(siteUrl, imageUrl, verbose, logger) {
         if (verbose) {
             await logger.logToStderr(`Retrieving information about the header image...`);