@pnp/cli-microsoft365 11.4.0-beta.87732f5 → 11.4.0-beta.f54089d

package/dist/m365/spfx/commands/project/project-upgrade/rules/DependencyRule.js

@@ -1,8 +1,15 @@
-import { lt, valid, validRange } from 'semver';
+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 _DependencyRule_instances, _DependencyRule_needsUpdate, _DependencyRule_getMaxVersion;
+import semver from 'semver';
 import { JsonRule } from '../../JsonRule.js';
 export class DependencyRule extends JsonRule {
     constructor(packageName, packageVersion, isDevDep = false, isOptional = false, add = true) {
         super();
+        _DependencyRule_instances.add(this);
         this.packageName = packageName;
         this.packageVersion = packageVersion;
         this.isDevDep = isDevDep;
@@ -39,23 +46,13 @@ export class DependencyRule extends JsonRule {
         }
         const projectDependencies = this.isDevDep ? project.packageJson.devDependencies : project.packageJson.dependencies;
         const versionEntry = projectDependencies ? projectDependencies[this.packageName] : '';
-        const packageVersion = valid(versionEntry);
-        const versionRange = validRange(versionEntry);
         if (this.add) {
             let jsonProperty = this.isDevDep ? 'devDependencies' : 'dependencies';
             if (versionEntry) {
                 jsonProperty += `.${this.packageName}`;
-                if (packageVersion) {
-                    if (lt(packageVersion, this.packageVersion)) {
-                        const node = this.getAstNodeFromFile(project.packageJson, jsonProperty);
-                        this.addFindingWithPosition(findings, node);
-                    }
-                }
-                else {
-                    if (versionRange) {
-                        const node = this.getAstNodeFromFile(project.packageJson, jsonProperty);
-                        this.addFindingWithPosition(findings, node);
-                    }
+                if (__classPrivateFieldGet(this, _DependencyRule_instances, "m", _DependencyRule_needsUpdate).call(this, this.packageVersion, versionEntry)) {
+                    const node = this.getAstNodeFromFile(project.packageJson, jsonProperty);
+                    this.addFindingWithPosition(findings, node);
                 }
             }
             else {
@@ -78,4 +75,49 @@ export class DependencyRule extends JsonRule {
         }
     }
 }
+_DependencyRule_instances = new WeakSet(), _DependencyRule_needsUpdate = function _DependencyRule_needsUpdate(ruleVersion, currentVersion) {
+    try {
+        // Get minimum versions for both
+        const ruleMin = semver.minVersion(ruleVersion);
+        const currentMin = semver.minVersion(currentVersion);
+        // Check if ranges overlap
+        const rangesOverlap = semver.intersects(ruleVersion, currentVersion);
+        if (rangesOverlap) {
+            // Even if they overlap, update if rule requires a higher minimum version
+            if (ruleMin && currentMin && semver.gt(ruleMin, currentMin)) {
+                return true;
+            }
+            return false;
+        }
+        // Ranges don't overlap - check if rule range is greater
+        // Get the maximum version that satisfies the current range
+        const currentMax = __classPrivateFieldGet(this, _DependencyRule_instances, "m", _DependencyRule_getMaxVersion).call(this, currentVersion);
+        // If rule's minimum is greater than current's maximum, update is needed
+        return !!(ruleMin && currentMax && semver.gt(ruleMin, currentMax));
+    }
+    catch {
+        return false;
+    }
+}, _DependencyRule_getMaxVersion = function _DependencyRule_getMaxVersion(range) {
+    const rangeObj = new semver.Range(range);
+    // If it's a specific version (no range operators), return it
+    if (semver.valid(range)) {
+        return semver.parse(range);
+    }
+    // For ranges, get the highest version from the set
+    // Check the range set to find upper bounds
+    let maxVer = null;
+    for (const comparatorSet of rangeObj.set) {
+        for (const comparator of comparatorSet) {
+            if (comparator.operator === '<' || comparator.operator === '<=') {
+                const ver = comparator.semver;
+                if (!maxVer || semver.gt(ver, maxVer)) {
+                    maxVer = ver;
+                }
+            }
+        }
+    }
+    // If no upper bound found, use minVersion as fallback
+    return maxVer || semver.minVersion(range);
+};
 //# sourceMappingURL=DependencyRule.js.map

package/dist/m365/spfx/commands/project/project-upgrade.js

@@ -7,19 +7,17 @@ import { z } from 'zod';
 import { CommandError, globalOptionsZod } from '../../../../Command.js';
 import { fsUtil } from '../../../../utils/fsUtil.js';
 import { packageManager } from '../../../../utils/packageManager.js';
-import { zod } from '../../../../utils/zod.js';
 import commands from '../../commands.js';
 import { BaseProjectCommand } from './base-project-command.js';
 import { FN017001_MISC_npm_dedupe } from './project-upgrade/rules/FN017001_MISC_npm_dedupe.js';
-const options = globalOptionsZod
-    .extend({
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
     packageManager: z.enum(['npm', 'pnpm', 'yarn']).default('npm'),
     preview: z.boolean().optional(),
-    toVersion: zod.alias('v', z.string().optional()),
+    toVersion: z.string().optional().alias('v'),
     shell: z.enum(['bash', 'powershell', 'cmd']).default('powershell'),
     output: z.enum(['json', 'text', 'md', 'tour', 'csv', 'none']).optional()
-})
-    .strict();
+});
 class SpfxProjectUpgradeCommand extends BaseProjectCommand {
     get name() {
         return commands.PROJECT_UPGRADE;

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

@@ -39,14 +39,38 @@ class SpoFileAddCommand extends SpoCommand {
     async commandAction(logger, args) {
         const folderPath = urlUtil.getServerRelativePath(args.options.webUrl, args.options.folder);
         const fullPath = path.resolve(args.options.path);
-        const fileName = fsUtil.getSafeFileName(path.basename(fullPath));
+        const fileName = fsUtil.getSafeFileName(args.options.fileName ?? path.basename(fullPath));
         let isCheckedOut = false;
         let listSettings;
         if (this.verbose) {
             await logger.logToStderr(`file name: ${fileName}...`);
             await logger.logToStderr(`folder path: ${folderPath}...`);
         }
+        if (args.options.overwrite === undefined) {
+            await this.warn(logger, 'In the next major version, the --overwrite option will default to false. To avoid this warning, please set the --overwrite option explicitly to true or false.');
+        }
         try {
+            if (args.options.overwrite === false) {
+                try {
+                    const requestOptions = {
+                        url: `${args.options.webUrl}/_api/Web/GetFileByServerRelativePath(DecodedUrl='${formatting.encodeQueryParameter(folderPath + '/' + fileName)}')?$select=Exists`,
+                        headers: {
+                            accept: 'application/json;odata=nometadata'
+                        },
+                        responseType: 'json'
+                    };
+                    await request.get(requestOptions);
+                    throw `File '${fileName}' already exists in folder '${folderPath}'. To overwrite the file, use the --overwrite option.`;
+                }
+                catch (err) {
+                    if (typeof err === 'string') {
+                        throw err;
+                    }
+                    if (this.verbose) {
+                        await logger.logToStderr(`File '${fileName}' does not exist in folder '${folderPath}'. Proceeding with upload.`);
+                    }
+                }
+            }
             try {
                 if (this.verbose) {
                     await logger.logToStderr('Check if the specified folder exists.');
@@ -78,6 +102,7 @@ class SpoFileAddCommand extends SpoCommand {
             if (this.verbose) {
                 await logger.logToStderr(`File size is ${fileSize} bytes`);
             }
+            let fileUploadResult;
             // only up to 250 MB are allowed in a single request
             if (fileSize > this.fileChunkingThreshold) {
                 const fileChunkCount = Math.ceil(fileSize / this.fileChunkSize);
@@ -106,7 +131,7 @@ class SpoFileAddCommand extends SpoCommand {
                     Size: fileSize
                 };
                 try {
-                    await this.uploadFileChunks(fileUploadInfo, logger);
+                    fileUploadResult = await this.uploadFileChunks(fileUploadInfo, logger);
                     if (this.verbose) {
                         await logger.logToStderr(`Finished uploading ${fileUploadInfo.Position} bytes in ${fileChunkCount} chunks`);
                     }
@@ -127,7 +152,7 @@ class SpoFileAddCommand extends SpoCommand {
                         throw err;
                     }
                     catch (err) {
-                        if (this.debug) {
+                        if (this.verbose) {
                             await logger.logToStderr(`Failed to cancel upload session: ${err}`);
                         }
                         throw err;
@@ -145,9 +170,10 @@ class SpoFileAddCommand extends SpoCommand {
                         accept: 'application/json;odata=nometadata',
                         'content-length': bodyLength
                     },
-                    maxBodyLength: this.fileChunkingThreshold
+                    maxBodyLength: this.fileChunkingThreshold,
+                    responseType: 'json'
                 };
-                await request.post(requestOptions);
+                fileUploadResult = await request.post(requestOptions);
             }
             if (args.options.contentType || args.options.publish || args.options.approve) {
                 listSettings = await this.getFileParentList(fileName, args.options.webUrl, folderPath, logger);
@@ -206,6 +232,7 @@ class SpoFileAddCommand extends SpoCommand {
                 };
                 await request.post(requestOptions);
             }
+            await logger.log(fileUploadResult);
         }
         catch (err) {
             if (isCheckedOut) {
@@ -292,15 +319,16 @@ class SpoFileAddCommand extends SpoCommand {
                     accept: 'application/json;odata=nometadata',
                     'content-length': readCount
                 },
-                maxBodyLength: this.fileChunkingThreshold
+                maxBodyLength: this.fileChunkingThreshold,
+                responseType: 'json'
             };
             try {
-                await request.post(requestOptions);
+                const uploadResponse = await request.post(requestOptions);
                 if (this.verbose) {
                     await logger.logToStderr(`Uploaded ${info.Position} of ${info.Size} bytes (${Math.round(100 * info.Position / info.Size)}%)`);
                 }
                 if (isLastChunk) {
-                    return;
+                    return uploadResponse;
                 }
                 else {
                     return this.uploadFileChunks(info, logger);
@@ -407,9 +435,12 @@ class SpoFileAddCommand extends SpoCommand {
             'approveComment',
             'publish',
             'publishComment',
+            'overwrite',
+            'fileName',
             'debug',
             'verbose',
             'output',
+            'query',
             '_',
             'u',
             'p',
@@ -434,7 +465,9 @@ _SpoFileAddCommand_instances = new WeakSet(), _SpoFileAddCommand_initTelemetry =
             approve: !!args.options.approve,
             approveComment: typeof args.options.approveComment !== 'undefined',
             publish: !!args.options.publish,
-            publishComment: typeof args.options.publishComment !== 'undefined'
+            publishComment: typeof args.options.publishComment !== 'undefined',
+            overwrite: !!args.options.overwrite,
+            fileName: typeof args.options.fileName !== 'undefined'
         });
     });
 }, _SpoFileAddCommand_initOptions = function _SpoFileAddCommand_initOptions() {
@@ -458,6 +491,11 @@ _SpoFileAddCommand_instances = new WeakSet(), _SpoFileAddCommand_initTelemetry =
         option: '--publish'
     }, {
         option: '--publishComment [publishComment]'
+    }, {
+        option: '--overwrite [overwrite]',
+        autocomplete: ['true', 'false']
+    }, {
+        option: '--fileName [fileName]'
     });
 }, _SpoFileAddCommand_initValidators = function _SpoFileAddCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -477,8 +515,8 @@ _SpoFileAddCommand_instances = new WeakSet(), _SpoFileAddCommand_initTelemetry =
         return true;
     });
 }, _SpoFileAddCommand_initTypes = function _SpoFileAddCommand_initTypes() {
-    this.types.string.push('webUrl', 'folder', 'path', 'contentType', 'checkInComment', 'approveComment', 'publishComment');
-    this.types.boolean.push('checkOut', 'approve', 'publish');
+    this.types.string.push('webUrl', 'folder', 'path', 'contentType', 'checkInComment', 'approveComment', 'publishComment', 'fileName');
+    this.types.boolean.push('checkOut', 'approve', 'publish', 'overwrite');
 };
 export default new SpoFileAddCommand();
 //# sourceMappingURL=file-add.js.map

package/dist/m365/spo/commands/file/file-version-keep.js

@@ -2,26 +2,22 @@ import commands from '../../commands.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import { validation } from '../../../../utils/validation.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
-export const options = globalOptionsZod
-    .extend({
-    webUrl: zod.alias('u', z.string()
-        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
-        message: `'${url}' is not a valid SharePoint Online site URL.`
-    }))),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    webUrl: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    })
+        .alias('u'),
     fileUrl: z.string().optional(),
-    fileId: zod.alias('i', z.string()
-        .refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional()),
+    fileId: z.uuid().optional().alias('i'),
     label: z.string()
-})
-    .strict();
+});
 class SpoFileVersionKeepCommand extends SpoCommand {
     get name() {
         return commands.FILE_VERSION_KEEP;
@@ -35,7 +31,7 @@ class SpoFileVersionKeepCommand extends SpoCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => [options.fileUrl, options.fileId].filter(o => o !== undefined).length === 1, {
-            message: `Specify 'fileUrl' or 'fileId', but not both.`
+            error: `Specify 'fileUrl' or 'fileId', but not both.`
         });
     }
     async commandAction(logger, args) {

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import { spo } from '../../../../utils/spo.js';
 import { validation } from '../../../../utils/validation.js';
@@ -7,25 +6,24 @@ import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
 import request from '../../../../request.js';
 import { entraGroup } from '../../../../utils/entraGroup.js';
-const options = globalOptionsZod
-    .extend({
-    url: zod.alias('u', z.string()
-        .refine((url) => validation.isValidSharePointUrl(url) === true, url => ({
-        message: `'${url}' is not a valid SharePoint Online site URL.`
-    }))),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    url: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    }).alias('u'),
     audienceIds: z.string()
-        .refine(audiences => validation.isValidGuidArray(audiences) === true, audiences => ({
-        message: `The following GUIDs are invalid: ${validation.isValidGuidArray(audiences)}.`
-    })).optional(),
+        .refine(audiences => validation.isValidGuidArray(audiences) === true, {
+        error: e => `The following GUIDs are invalid: ${e.input}.`
+    }).optional(),
     audienceNames: z.string().optional(),
     vivaConnectionsDefaultStart: z.boolean().optional(),
     isInDraftMode: z.boolean().optional(),
     order: z.number()
-        .refine(order => validation.isValidPositiveInteger(order) === true, order => ({
-        message: `'${order}' is not a positive integer.`
-    })).optional()
-})
-    .strict();
+        .refine(order => validation.isValidPositiveInteger(order) === true, {
+        error: e => `'${e.input}' is not a positive integer.`
+    }).optional()
+});
 class SpoHomeSiteAddCommand extends SpoCommand {
     get name() {
         return commands.HOMESITE_ADD;

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import { validation } from '../../../../utils/validation.js';
 import { spo } from '../../../../utils/spo.js';
@@ -7,14 +6,14 @@ import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
 import { odata } from '../../../../utils/odata.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
-const options = globalOptionsZod
-    .extend({
-    url: zod.alias('u', z.string()
-        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
-        message: `'${url}' is not a valid SharePoint Online site URL.`
-    })))
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    url: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    })
+        .alias('u')
+});
 class SpoHomeSiteGetCommand extends SpoCommand {
     get name() {
         return commands.HOMESITE_GET;

package/dist/m365/spo/commands/homesite/homesite-remove.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import { validation } from '../../../../utils/validation.js';
 import { cli } from '../../../../cli/cli.js';
@@ -7,15 +6,15 @@ import request from '../../../../request.js';
 import { spo } from '../../../../utils/spo.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
-const options = globalOptionsZod
-    .extend({
-    url: zod.alias('u', z.string()
-        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
-        message: `'${url}' is not a valid SharePoint Online site URL.`
-    }))),
-    force: zod.alias('f', z.boolean().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    url: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    })
+        .alias('u'),
+    force: z.boolean().optional().alias('f')
+});
 class SpoHomeSiteRemoveCommand extends SpoCommand {
     get name() {
         return commands.HOMESITE_REMOVE;

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
 import { spo } from '../../../../utils/spo.js';
@@ -7,24 +6,24 @@ import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
 import { entraGroup } from '../../../../utils/entraGroup.js';
-const optionsSchema = globalOptionsZod
-    .extend({
-    url: zod.alias('u', z.string()
-        .refine((url) => validation.isValidSharePointUrl(url) === true, url => ({
-        message: `'${url}' is not a valid SharePoint Online site URL.`
-    }))),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    url: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    }).alias('u'),
     vivaConnectionsDefaultStart: z.boolean().optional(),
     draftMode: z.boolean().optional(),
     audienceIds: z.string()
-        .refine(audiences => validation.isValidGuidArray(audiences) === true, audiences => ({
-        message: `The following GUIDs are invalid: ${validation.isValidGuidArray(audiences)}.`
-    })).optional(),
+        .refine(audiences => validation.isValidGuidArray(audiences) === true, {
+        error: e => `The following GUIDs are invalid: ${e.input}.`
+    }).optional(),
     audienceNames: z.string().optional(),
     targetedLicenseType: z.enum(['everyone', 'frontLineWorkers', 'informationWorkers']).optional(),
     order: z.number()
-        .refine(order => validation.isValidPositiveInteger(order) === true, order => ({
-        message: `'${order}' is not a positive integer.`
-    })).optional()
+        .refine(order => validation.isValidPositiveInteger(order) === true, {
+        error: e => `'${e.input}' is not a positive integer.`
+    }).optional()
 });
 class SpoHomeSiteSetCommand extends SpoCommand {
     get name() {
@@ -34,7 +33,7 @@ class SpoHomeSiteSetCommand extends SpoCommand {
         return 'Updates an existing SharePoint home site.';
     }
     get schema() {
-        return optionsSchema;
+        return options;
     }
     getRefinedSchema(schema) {
         return schema

package/dist/m365/spo/commands/list/DefaultColumnValue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DefaultColumnValue.js.map

package/dist/m365/spo/commands/list/list-defaultvalue-clear.js

@@ -1,7 +1,6 @@
 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 { DOMParser } from '@xmldom/xmldom';
 import { validation } from '../../../../utils/validation.js';
@@ -9,23 +8,20 @@ import { urlUtil } from '../../../../utils/urlUtil.js';
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { cli } from '../../../../cli/cli.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 Online site URL.`
-    }))),
-    listId: zod.alias('i', z.string().optional()
-        .refine(id => id === undefined || validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    }))),
-    listTitle: zod.alias('t', z.string().optional()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    webUrl: z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, {
+        error: e => `'${e.input}' is not a valid SharePoint Online site URL.`
+    })
+        .alias('u'),
+    listId: z.uuid().optional().alias('i'),
+    listTitle: z.string().optional().alias('t'),
     listUrl: z.string().optional(),
     fieldName: z.string().optional(),
     folderUrl: z.string().optional(),
-    force: zod.alias('f', z.boolean().optional())
-})
-    .strict();
+    force: z.boolean().optional().alias('f')
+});
 class SpoListDefaultValueClearCommand extends SpoCommand {
     get name() {
         return commands.LIST_DEFAULTVALUE_CLEAR;
@@ -39,10 +35,10 @@ class SpoListDefaultValueClearCommand extends SpoCommand {
     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, listUrl.'
+            error: 'Use one of the following options: listId, listTitle, listUrl.'
         })
             .refine(options => (options.fieldName !== undefined) !== (options.folderUrl !== undefined) || (options.fieldName === undefined && options.folderUrl === undefined), {
-            message: `Specify 'fieldName' or 'folderUrl', but not both.`
+            error: `Specify 'fieldName' or 'folderUrl', but not both.`
         });
     }
     async commandAction(logger, args) {