@pnp/cli-microsoft365 8.0.0-beta.e6f9331 → 8.1.0-beta.3a80e6f

package/dist/m365/entra/commands/multitenant/multitenant-remove.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 _EntraMultitenantRemoveCommand_instances, _EntraMultitenantRemoveCommand_initTelemetry, _EntraMultitenantRemoveCommand_initOptions;
+import request from '../../../../request.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { odata } from '../../../../utils/odata.js';
+import { cli } from '../../../../cli/cli.js';
+class EntraMultitenantRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.MULTITENANT_REMOVE;
+    }
+    get description() {
+        return 'Removes a multitenant organization';
+    }
+    constructor() {
+        super();
+        _EntraMultitenantRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraMultitenantRemoveCommand_instances, "m", _EntraMultitenantRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraMultitenantRemoveCommand_instances, "m", _EntraMultitenantRemoveCommand_initOptions).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeMultitenantOrg = async () => {
+            try {
+                const tenantId = await this.getCurrentTenantId();
+                let tenantsId = await this.getAllTenantsIds();
+                const tenantsCount = tenantsId.length;
+                if (tenantsCount > 0) {
+                    const tasks = tenantsId
+                        .filter(x => x !== tenantId)
+                        .map(t => this.removeTenant(logger, t));
+                    await Promise.all(tasks);
+                    do {
+                        if (this.verbose) {
+                            await logger.logToStderr(`Waiting 30 seconds...`);
+                        }
+                        await new Promise(resolve => setTimeout(resolve, 30000));
+                        // from current behavior, removing tenant can take a few seconds
+                        // current tenant must be removed once all previous ones were removed
+                        if (this.verbose) {
+                            await logger.logToStderr(`Checking all tenants were removed...`);
+                        }
+                        tenantsId = await this.getAllTenantsIds();
+                        if (this.verbose) {
+                            await logger.logToStderr(`Number of removed tenants: ${tenantsCount - tenantsId.length}`);
+                        }
+                    } while (tenantsId.length !== 1);
+                    // current tenant must be removed as the last one
+                    await this.removeTenant(logger, tenantId);
+                    await logger.logToStderr('Your Multi-Tenant organization is being removed. This can take up to 2 hours.');
+                }
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeMultitenantOrg();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: 'Are you sure you want to remove multitenant organization?' });
+            if (result) {
+                await removeMultitenantOrg();
+            }
+        }
+    }
+    async getAllTenantsIds() {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/tenantRelationships/multiTenantOrganization/tenants?$select=tenantId`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const tenants = await odata.getAllItems(requestOptions);
+        return tenants.map(x => x.tenantId);
+    }
+    async getCurrentTenantId() {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/organization?$select=id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const organizations = await odata.getAllItems(requestOptions);
+        return organizations[0].id;
+    }
+    async removeTenant(logger, tenantId) {
+        if (this.verbose) {
+            await logger.logToStderr(`Removing tenant: ${tenantId}`);
+        }
+        const requestOptions = {
+            url: `${this.resource}/v1.0/tenantRelationships/multiTenantOrganization/tenants/${tenantId}`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        await request.delete(requestOptions);
+    }
+}
+_EntraMultitenantRemoveCommand_instances = new WeakSet(), _EntraMultitenantRemoveCommand_initTelemetry = function _EntraMultitenantRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            force: !!args.options.force
+        });
+    });
+}, _EntraMultitenantRemoveCommand_initOptions = function _EntraMultitenantRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-f, --force'
+    });
+};
+export default new EntraMultitenantRemoveCommand();
+//# sourceMappingURL=multitenant-remove.js.map

package/dist/m365/entra/commands/multitenant/multitenant-set.js

@@ -0,0 +1,72 @@
+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 _EntraMultitenantSetCommand_instances, _EntraMultitenantSetCommand_initTelemetry, _EntraMultitenantSetCommand_initOptions, _EntraMultitenantSetCommand_initValidators, _EntraMultitenantSetCommand_initTypes;
+import request from '../../../../request.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class EntraMultitenantSetCommand extends GraphCommand {
+    get name() {
+        return commands.MULTITENANT_SET;
+    }
+    get description() {
+        return 'Updates the properties of a multitenant organization';
+    }
+    constructor() {
+        super();
+        _EntraMultitenantSetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraMultitenantSetCommand_instances, "m", _EntraMultitenantSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraMultitenantSetCommand_instances, "m", _EntraMultitenantSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraMultitenantSetCommand_instances, "m", _EntraMultitenantSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraMultitenantSetCommand_instances, "m", _EntraMultitenantSetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            await logger.logToStderr('Updating multitenant organization...');
+        }
+        const requestOptions = {
+            url: `${this.resource}/v1.0/tenantRelationships/multiTenantOrganization`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                description: args.options.description,
+                displayName: args.options.displayName
+            }
+        };
+        try {
+            await request.patch(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_EntraMultitenantSetCommand_instances = new WeakSet(), _EntraMultitenantSetCommand_initTelemetry = function _EntraMultitenantSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            displayName: typeof args.options.displayName !== 'undefined',
+            description: typeof args.options.description !== 'undefined'
+        });
+    });
+}, _EntraMultitenantSetCommand_initOptions = function _EntraMultitenantSetCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --displayName [displayName]'
+    }, {
+        option: '-d, --description [description]'
+    });
+}, _EntraMultitenantSetCommand_initValidators = function _EntraMultitenantSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (!args.options.displayName && !args.options.description) {
+            return 'Specify either displayName or description or both.';
+        }
+        return true;
+    });
+}, _EntraMultitenantSetCommand_initTypes = function _EntraMultitenantSetCommand_initTypes() {
+    this.types.string.push('displayName', 'description');
+};
+export default new EntraMultitenantSetCommand();
+//# sourceMappingURL=multitenant-set.js.map

package/dist/m365/entra/commands.js

@@ -72,6 +72,10 @@ export default {
     M365GROUP_USER_LIST: `${prefix} m365group user list`,
     M365GROUP_USER_REMOVE: `${prefix} m365group user remove`,
     M365GROUP_USER_SET: `${prefix} m365group user set`,
+    MULTITENANT_ADD: `${prefix} multitenant add`,
+    MULTITENANT_GET: `${prefix} multitenant get`,
+    MULTITENANT_REMOVE: `${prefix} multitenant remove`,
+    MULTITENANT_SET: `${prefix} multitenant set`,
     OAUTH2GRANT_ADD: `${prefix} oauth2grant add`,
     OAUTH2GRANT_LIST: `${prefix} oauth2grant list`,
     OAUTH2GRANT_REMOVE: `${prefix} oauth2grant remove`,

package/dist/m365/external/commands/connection/connection-doctor.js

@@ -5,11 +5,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _ExternalConnectionDoctorCommand_instances, _a, _ExternalConnectionDoctorCommand_initOptions, _ExternalConnectionDoctorCommand_initValidators;
 import os from 'os';
-import { cli } from '../../../../cli/cli.js';
 import request from '../../../../request.js';
-import { settingsNames } from '../../../../settingsNames.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
+import { CheckStatus, formatting } from '../../../../utils/formatting.js';
 class ExternalConnectionDoctorCommand extends GraphCommand {
     get name() {
         return commands.CONNECTION_DOCTOR;
@@ -28,9 +27,7 @@ class ExternalConnectionDoctorCommand extends GraphCommand {
         const ux = args.options.ux ?? 'all';
         const output = args.options.output;
         this.checksStatus = [];
-        const showSpinner = cli.getSettingWithDefaultValue(settingsNames.showSpinner, true) &&
-            output === 'text' &&
-            typeof global.it === 'undefined';
+        const show = output === 'text';
         let checks = [
             {
                 id: 'loadExternalConnection',
@@ -114,17 +111,10 @@ class ExternalConnectionDoctorCommand extends GraphCommand {
             if (this.debug) {
                 await logger.logToStderr(`Running check ${check.id}...`);
             }
-            // don't show spinner if running tests
-            /* c8 ignore next 3 */
-            if (showSpinner) {
-                cli.spinner.start(check.text);
-            }
             // only automated checks have functions
             if (!check.fn) {
-                // don't show spinner if running tests
-                /* c8 ignore next 3 */
-                if (showSpinner) {
-                    cli.spinner.info(`${check.text} (manual)`);
+                if (show) {
+                    await logger.log(formatting.getStatus(CheckStatus.Information, `${check.text} (manual)`));
                 }
                 this.checksStatus.push({
                     ...check,
@@ -135,23 +125,19 @@ class ExternalConnectionDoctorCommand extends GraphCommand {
             const result = await check.fn.bind(this)(check.id, args);
             this.checksStatus.push({ ...check, ...result });
             if (result.status === 'passed') {
-                // don't show spinner if running tests
-                /* c8 ignore next 3 */
-                if (showSpinner) {
-                    cli.spinner.succeed();
+                if (show) {
+                    await logger.log(formatting.getStatus(CheckStatus.Success, check.text));
                 }
                 continue;
             }
             if (result.status === 'failed') {
-                // don't show spinner if running tests
-                /* c8 ignore next 9 */
-                if (showSpinner) {
+                if (show) {
                     const message = `${check.text}: ${result.errorMessage}`;
                     if (check.type === 'required') {
-                        cli.spinner.fail(message);
+                        await logger.log(formatting.getStatus(CheckStatus.Failure, message));
                     }
                     else {
-                        cli.spinner.warn(message);
+                        await logger.log(formatting.getStatus(CheckStatus.Warning, check.text));
                     }
                 }
                 if (result.shouldStop) {
@@ -159,7 +145,7 @@ class ExternalConnectionDoctorCommand extends GraphCommand {
                 }
             }
         }
-        if (output === 'text' || output === 'none') {
+        if (show || output === 'none') {
             return;
         }
         this.checksStatus.forEach(s => {

package/dist/m365/flow/commands/flow-get.js

@@ -29,7 +29,7 @@ class FlowGetCommand extends PowerAutomateCommand {
             await logger.logToStderr(`Retrieving information about Microsoft Flow ${args.options.name}...`);
         }
         const requestOptions = {
-            url: `${this.resource}/providers/Microsoft.ProcessSimple/${args.options.asAdmin ? 'scopes/admin/' : ''}environments/${formatting.encodeQueryParameter(args.options.environmentName)}/flows/${formatting.encodeQueryParameter(args.options.name)}?api-version=2016-11-01`,
+            url: `${this.resource}/providers/Microsoft.ProcessSimple/${args.options.asAdmin ? 'scopes/admin/' : ''}environments/${formatting.encodeQueryParameter(args.options.environmentName)}/flows/${formatting.encodeQueryParameter(args.options.name)}?api-version=2016-11-01&$expand=swagger,properties.connectionreferences.apidefinition,properties.definitionsummary.operations.apioperation,operationDefinition,plan,properties.throttleData,properties.estimatedsuspensiondata,properties.licenseData`,
             headers: {
                 accept: 'application/json'
             },

package/dist/m365/flow/commands/flow-list.js

@@ -46,7 +46,8 @@ class FlowListCommand extends PowerAutomateCommand {
                 let url = this.getApiUrl(environmentName, asAdmin, includeSolutions, 'personal');
                 items = await odata.getAllItems(url);
                 url = this.getApiUrl(environmentName, asAdmin, includeSolutions, 'team');
-                items = await odata.getAllItems(url);
+                const teamFlows = await odata.getAllItems(url);
+                items = items.concat(teamFlows);
             }
             else {
                 const url = this.getApiUrl(environmentName, asAdmin, includeSolutions);

package/dist/m365/graph/commands/subscription/subscription-add.js

@@ -141,8 +141,10 @@ _GraphSubscriptionAddCommand_instances = new WeakSet(), _GraphSubscriptionAddCom
     });
 }, _GraphSubscriptionAddCommand_initValidators = function _GraphSubscriptionAddCommand_initValidators() {
     this.validators.push(async (args) => {
-        if (args.options.notificationUrl.indexOf('https://') !== 0) {
-            return `The specified notification URL '${args.options.notificationUrl}' does not start with 'https://'`;
+        if (!args.options.notificationUrl.toLowerCase().startsWith('https://')
+            && !args.options.notificationUrl.toLowerCase().startsWith('eventhub:https://')
+            && !args.options.notificationUrl.toLowerCase().startsWith('eventgrid:?azuresubscriptionid=')) {
+            return `The specified notification URL '${args.options.notificationUrl}' does not start with either 'https://' or 'EventHub:https://' or 'EventGrid:?azuresubscriptionid='`;
         }
         if (!this.isValidChangeTypes(args.options.changeTypes)) {
             return `The specified changeTypes are invalid. Valid options are 'created', 'updated' and 'deleted'`;

package/dist/m365/spe/ContainerTypeProperties.js

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

package/dist/m365/spe/commands/containertype/containertype-list.js

@@ -0,0 +1,49 @@
+import config from '../../../../config.js';
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpeContainertypeListCommand extends SpoCommand {
+    get name() {
+        return commands.CONTAINERTYPE_LIST;
+    }
+    get description() {
+        return 'Lists all Container Types';
+    }
+    defaultProperties() {
+        return ['ContainerTypeId', 'DisplayName', 'OwningAppId'];
+    }
+    async commandAction(logger) {
+        try {
+            const spoAdminUrl = await spo.getSpoAdminUrl(logger, this.debug);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving list of Container types...`);
+            }
+            const allContainerTypes = await this.getAllContainerTypes(spoAdminUrl, logger);
+            await logger.log(allContainerTypes);
+        }
+        catch (err) {
+            this.handleRejectedPromise(err);
+        }
+    }
+    async getAllContainerTypes(spoAdminUrl, logger) {
+        const formDigestInfo = await spo.ensureFormDigest(spoAdminUrl, logger, undefined, this.debug);
+        const requestOptions = {
+            url: `${spoAdminUrl}/_vti_bin/client.svc/ProcessQuery`,
+            headers: {
+                'X-RequestDigest': formDigestInfo.FormDigestValue
+            },
+            data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="46" ObjectPathId="45" /><Method Name="GetSPOContainerTypes" Id="47" ObjectPathId="45"><Parameters><Parameter Type="Enum">1</Parameter></Parameters></Method></Actions><ObjectPaths><Constructor Id="45" TypeId="{268004ae-ef6b-4e9b-8425-127220d84719}" /></ObjectPaths></Request>`
+        };
+        const res = await request.post(requestOptions);
+        const json = JSON.parse(res);
+        const response = json[0];
+        if (response.ErrorInfo) {
+            throw response.ErrorInfo.ErrorMessage;
+        }
+        const containerTypes = json[json.length - 1];
+        return containerTypes;
+    }
+}
+export default new SpeContainertypeListCommand();
+//# sourceMappingURL=containertype-list.js.map

package/dist/m365/spe/commands.js

@@ -1,5 +1,6 @@
 const prefix = 'spe';
 export default {
-    CONTAINERTYPE_ADD: `${prefix} containertype add`
+    CONTAINERTYPE_ADD: `${prefix} containertype add`,
+    CONTAINERTYPE_LIST: `${prefix} containertype list`
 };
 //# sourceMappingURL=commands.js.map

package/dist/m365/spfx/commands/project/base-project-command.js

@@ -4,6 +4,7 @@ import { formatting } from '../../../../utils/formatting.js';
 import { fsUtil } from '../../../../utils/fsUtil.js';
 import AnonymousCommand from "../../../base/AnonymousCommand.js";
 import { ScssFile, TsFile } from "./project-model/index.js";
+import { CommandError } from '../../../../Command.js';
 export class BaseProjectCommand extends AnonymousCommand {
     constructor() {
         super(...arguments);
@@ -31,105 +32,17 @@ export class BaseProjectCommand extends AnonymousCommand {
             }
             catch { }
         }
-        const configJsonPath = path.join(projectRootPath, 'config/config.json');
-        if (fs.existsSync(configJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(configJsonPath, 'utf-8'));
-                project.configJson = JSON.parse(source);
-                project.configJson.source = source;
-            }
-            catch { }
-        }
-        const copyAssetsJsonPath = path.join(projectRootPath, 'config/copy-assets.json');
-        if (fs.existsSync(copyAssetsJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(copyAssetsJsonPath, 'utf-8'));
-                project.copyAssetsJson = JSON.parse(source);
-                project.copyAssetsJson.source = source;
-            }
-            catch { }
-        }
-        const deployAzureStorageJsonPath = path.join(projectRootPath, 'config/deploy-azure-storage.json');
-        if (fs.existsSync(deployAzureStorageJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(deployAzureStorageJsonPath, 'utf-8'));
-                project.deployAzureStorageJson = JSON.parse(source);
-                project.deployAzureStorageJson.source = source;
-            }
-            catch { }
-        }
-        const packageJsonPath = path.join(projectRootPath, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(packageJsonPath, 'utf-8'));
-                project.packageJson = JSON.parse(source);
-                project.packageJson.source = source;
-            }
-            catch { }
-        }
-        const packageSolutionJsonPath = path.join(projectRootPath, 'config/package-solution.json');
-        if (fs.existsSync(packageSolutionJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(packageSolutionJsonPath, 'utf-8'));
-                project.packageSolutionJson = JSON.parse(source);
-                project.packageSolutionJson.source = source;
-            }
-            catch { }
-        }
-        const serveJsonPath = path.join(projectRootPath, 'config/serve.json');
-        if (fs.existsSync(serveJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(serveJsonPath, 'utf-8'));
-                project.serveJson = JSON.parse(source);
-                project.serveJson.source = source;
-            }
-            catch { }
-        }
-        const tsConfigJsonPath = path.join(projectRootPath, 'tsconfig.json');
-        if (fs.existsSync(tsConfigJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsConfigJsonPath, 'utf-8'));
-                project.tsConfigJson = JSON.parse(source);
-                project.tsConfigJson.source = source;
-            }
-            catch { }
-        }
-        const tsLintJsonPath = path.join(projectRootPath, 'config/tslint.json');
-        if (fs.existsSync(tsLintJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsLintJsonPath, 'utf-8'));
-                project.tsLintJson = JSON.parse(source);
-                project.tsLintJson.source = source;
-            }
-            catch { }
-        }
-        const tsLintJsonRootPath = path.join(projectRootPath, 'tslint.json');
-        if (fs.existsSync(tsLintJsonRootPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsLintJsonRootPath, 'utf-8'));
-                project.tsLintJsonRoot = JSON.parse(source);
-                project.tsLintJsonRoot.source = source;
-            }
-            catch { }
-        }
-        const writeManifestJsonPath = path.join(projectRootPath, 'config/write-manifests.json');
-        if (fs.existsSync(writeManifestJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(writeManifestJsonPath, 'utf-8'));
-                project.writeManifestsJson = JSON.parse(source);
-                project.writeManifestsJson.source = source;
-            }
-            catch { }
-        }
-        const yoRcJsonPath = path.join(projectRootPath, '.yo-rc.json');
-        if (fs.existsSync(yoRcJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(yoRcJsonPath, 'utf-8'));
-                project.yoRcJson = JSON.parse(source);
-                project.yoRcJson.source = source;
-            }
-            catch { }
-        }
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'config.json'), project, 'configJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'copy-assets.json'), project, 'copyAssetsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'deploy-azure-storage.json'), project, 'deployAzureStorageJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'package.json'), project, 'packageJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'package-solution.json'), project, 'packageSolutionJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'serve.json'), project, 'serveJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'tsconfig.json'), project, 'tsConfigJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'tslint.json'), project, 'tsLintJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'tslint.json'), project, 'tsLintJsonRoot');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'write-manifests.json'), project, 'writeManifestsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.yo-rc.json'), project, 'yoRcJson');
         const gulpfileJsPath = path.join(projectRootPath, 'gulpfile.js');
         if (fs.existsSync(gulpfileJsPath)) {
             project.gulpfileJs = {
@@ -141,33 +54,9 @@ export class BaseProjectCommand extends AnonymousCommand {
             project.esLintRcJs = new TsFile(esLintRcJsPath);
         }
         project.vsCode = {};
-        const vsCodeSettingsPath = path.join(projectRootPath, '.vscode', 'settings.json');
-        if (fs.existsSync(vsCodeSettingsPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeSettingsPath, 'utf-8'));
-                project.vsCode.settingsJson = JSON.parse(source);
-                project.vsCode.settingsJson.source = source;
-            }
-            catch { }
-        }
-        const vsCodeExtensionsPath = path.join(projectRootPath, '.vscode', 'extensions.json');
-        if (fs.existsSync(vsCodeExtensionsPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeExtensionsPath, 'utf-8'));
-                project.vsCode.extensionsJson = JSON.parse(source);
-                project.vsCode.extensionsJson.source = source;
-            }
-            catch { }
-        }
-        const vsCodeLaunchPath = path.join(projectRootPath, '.vscode', 'launch.json');
-        if (fs.existsSync(vsCodeLaunchPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeLaunchPath, 'utf-8'));
-                project.vsCode.launchJson = JSON.parse(source);
-                project.vsCode.launchJson.source = source;
-            }
-            catch { }
-        }
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'settings.json'), project, 'vsCode.settingsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'extensions.json'), project, 'vsCode.extensionsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'launch.json'), project, 'vsCode.launchJson');
         const srcFiles = fsUtil.readdirR(path.join(projectRootPath, 'src'));
         const manifestFiles = srcFiles.filter(f => f.endsWith('.manifest.json'));
         const manifests = manifestFiles.map((f) => {
@@ -233,5 +122,26 @@ export class BaseProjectCommand extends AnonymousCommand {
         catch { }
         return undefined;
     }
+    readAndParseJsonFile(filePath, project, keyPath) {
+        if (fs.existsSync(filePath)) {
+            try {
+                const source = formatting.removeSingleLineComments(fs.readFileSync(filePath, 'utf-8'));
+                const keys = keyPath.split('.');
+                let current = project;
+                for (let i = 0; i < keys.length - 1; i++) {
+                    current = current[keys[i]];
+                }
+                const finalKey = keys[keys.length - 1];
+                current[finalKey] = JSON.parse(source);
+                if (typeof current[finalKey] === 'object' && current[finalKey] !== null) {
+                    current[finalKey].source = source;
+                }
+            }
+            catch (error) {
+                throw new CommandError(`The file ${filePath} is not a valid JSON file or is not utf-8 encoded. Error: ${error}`);
+            }
+        }
+        return project;
+    }
 }
 //# sourceMappingURL=base-project-command.js.map

package/dist/m365/spo/commands/applicationcustomizer/applicationcustomizer-get.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 _SpoApplicationCustomizerGetCommand_instances, _SpoApplicationCustomizerGetCommand_initTelemetry, _SpoApplicationCustomizerGetCommand_initOptions, _SpoApplicationCustomizerGetCommand_initValidators, _SpoApplicationCustomizerGetCommand_initOptionSets;
+var _SpoApplicationCustomizerGetCommand_instances, _SpoApplicationCustomizerGetCommand_initTelemetry, _SpoApplicationCustomizerGetCommand_initOptions, _SpoApplicationCustomizerGetCommand_initValidators, _SpoApplicationCustomizerGetCommand_initOptionSets, _SpoApplicationCustomizerGetCommand_initTypes;
 import { formatting } from '../../../../utils/formatting.js';
 import { spo } from '../../../../utils/spo.js';
 import { validation } from '../../../../utils/validation.js';
@@ -25,33 +25,22 @@ class SpoApplicationCustomizerGetCommand extends SpoCommand {
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoApplicationCustomizerGetCommand_instances, "m", _SpoApplicationCustomizerGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         try {
             const customAction = await this.getCustomAction(args.options);
-            if (customAction) {
+            if (!args.options.clientSideComponentProperties) {
                 await logger.log({
-                    ClientSideComponentId: customAction.ClientSideComponentId,
-                    ClientSideComponentProperties: customAction.ClientSideComponentProperties,
-                    CommandUIExtension: customAction.CommandUIExtension,
-                    Description: customAction.Description,
-                    Group: customAction.Group,
-                    Id: customAction.Id,
-                    ImageUrl: customAction.ImageUrl,
-                    Location: customAction.Location,
-                    Name: customAction.Name,
-                    RegistrationId: customAction.RegistrationId,
-                    RegistrationType: customAction.RegistrationType,
+                    ...customAction,
                     Rights: JSON.stringify(customAction.Rights),
-                    Scope: this.humanizeScope(customAction.Scope),
-                    ScriptBlock: customAction.ScriptBlock,
-                    ScriptSrc: customAction.ScriptSrc,
-                    Sequence: customAction.Sequence,
-                    Title: customAction.Title,
-                    Url: customAction.Url,
-                    VersionOfUserCustomAction: customAction.VersionOfUserCustomAction
+                    Scope: this.humanizeScope(customAction.Scope)
                 });
             }
+            else {
+                const properties = formatting.tryParseJson(customAction.ClientSideComponentProperties);
+                await logger.log(properties);
+            }
         }
         catch (err) {
             this.handleRejectedPromise(err);
@@ -95,7 +84,8 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
             title: typeof args.options.title !== 'undefined',
             id: typeof args.options.id !== 'undefined',
             clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined',
-            scope: typeof args.options.scope !== 'undefined'
+            scope: typeof args.options.scope !== 'undefined',
+            clientSideComponentProperties: !!args.options.clientSideComponentProperties
         });
     });
 }, _SpoApplicationCustomizerGetCommand_initOptions = function _SpoApplicationCustomizerGetCommand_initOptions() {
@@ -110,6 +100,8 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
     }, {
         option: '-s, --scope [scope]',
         autocomplete: this.allowedScopes
+    }, {
+        option: '-p, --clientSideComponentProperties'
     });
 }, _SpoApplicationCustomizerGetCommand_initValidators = function _SpoApplicationCustomizerGetCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -126,6 +118,9 @@ _SpoApplicationCustomizerGetCommand_instances = new WeakSet(), _SpoApplicationCu
     });
 }, _SpoApplicationCustomizerGetCommand_initOptionSets = function _SpoApplicationCustomizerGetCommand_initOptionSets() {
     this.optionSets.push({ options: ['title', 'id', 'clientSideComponentId'] });
+}, _SpoApplicationCustomizerGetCommand_initTypes = function _SpoApplicationCustomizerGetCommand_initTypes() {
+    this.types.string.push('webUrl', 'title', 'id', 'clientSideComponentId', 'scope');
+    this.types.boolean.push('clientSideComponentProperties');
 };
 export default new SpoApplicationCustomizerGetCommand();
 //# sourceMappingURL=applicationcustomizer-get.js.map