@microsoft/m365-spec-parser 0.2.2-alpha.ca8431921.0 → 0.2.2-alpha.db6b164d0.0

package/dist/index.node.cjs.js

@@ -1147,6 +1147,161 @@ class ValidatorFactory {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+class SpecOptimizer {
+    static optimize(spec, options) {
+        const mergedOptions = Object.assign(Object.assign({}, SpecOptimizer.defaultOptions), (options !== null && options !== void 0 ? options : {}));
+        const newSpec = JSON.parse(JSON.stringify(spec));
+        if (mergedOptions.removeUserDefinedRootProperty) {
+            SpecOptimizer.removeUserDefinedRootProperty(newSpec);
+        }
+        if (mergedOptions.removeUnusedComponents) {
+            SpecOptimizer.removeUnusedComponents(newSpec);
+        }
+        if (mergedOptions.removeUnusedTags) {
+            SpecOptimizer.removeUnusedTags(newSpec);
+        }
+        if (mergedOptions.removeUnusedSecuritySchemas) {
+            SpecOptimizer.removeUnusedSecuritySchemas(newSpec);
+        }
+        return newSpec;
+    }
+    static removeUnusedSecuritySchemas(spec) {
+        if (!spec.components || !spec.components.securitySchemes) {
+            return;
+        }
+        const usedSecuritySchemas = new Set();
+        for (const pathKey in spec.paths) {
+            for (const methodKey in spec.paths[pathKey]) {
+                const operation = spec.paths[pathKey][methodKey];
+                if (operation.security) {
+                    operation.security.forEach((securityReq) => {
+                        for (const schemaKey in securityReq) {
+                            usedSecuritySchemas.add(schemaKey);
+                        }
+                    });
+                }
+            }
+        }
+        if (spec.security) {
+            spec.security.forEach((securityReq) => {
+                for (const schemaKey in securityReq) {
+                    usedSecuritySchemas.add(schemaKey);
+                }
+            });
+        }
+        for (const schemaKey in spec.components.securitySchemes) {
+            if (!usedSecuritySchemas.has(schemaKey)) {
+                delete spec.components.securitySchemes[schemaKey];
+            }
+        }
+        if (Object.keys(spec.components.securitySchemes).length === 0) {
+            delete spec.components.securitySchemes;
+        }
+        if (Object.keys(spec.components).length === 0) {
+            delete spec.components;
+        }
+    }
+    static removeUnusedTags(spec) {
+        if (!spec.tags) {
+            return;
+        }
+        const usedTags = new Set();
+        for (const pathKey in spec.paths) {
+            for (const methodKey in spec.paths[pathKey]) {
+                const operation = spec.paths[pathKey][methodKey];
+                if (operation.tags) {
+                    operation.tags.forEach((tag) => usedTags.add(tag));
+                }
+            }
+        }
+        spec.tags = spec.tags.filter((tagObj) => usedTags.has(tagObj.name));
+    }
+    static removeUserDefinedRootProperty(spec) {
+        for (const key in spec) {
+            if (key.startsWith("x-")) {
+                delete spec[key];
+            }
+        }
+    }
+    static removeUnusedComponents(spec) {
+        const components = spec.components;
+        if (!components) {
+            return;
+        }
+        delete spec.components;
+        const usedComponentsSet = new Set();
+        const specString = JSON.stringify(spec);
+        const componentReferences = SpecOptimizer.getComponentReferences(specString);
+        for (const reference of componentReferences) {
+            this.addComponent(reference, usedComponentsSet, components);
+        }
+        const newComponents = {};
+        for (const componentName of usedComponentsSet) {
+            const parts = componentName.split("/");
+            const component = this.getComponent(componentName, components);
+            if (component) {
+                let current = newComponents;
+                for (let i = 2; i < parts.length; i++) {
+                    if (i === parts.length - 1) {
+                        current[parts[i]] = component;
+                    }
+                    else if (!current[parts[i]]) {
+                        current[parts[i]] = {};
+                    }
+                    current = current[parts[i]];
+                }
+            }
+        }
+        // securitySchemes are referenced directly by name, to void issue, just keep them all and use removeUnusedSecuritySchemas to remove unused ones
+        if (components.securitySchemes) {
+            newComponents.securitySchemes = components.securitySchemes;
+        }
+        if (Object.keys(newComponents).length !== 0) {
+            spec.components = newComponents;
+        }
+    }
+    static getComponentReferences(specString) {
+        const matches = Array.from(specString.matchAll(/['"](#\/components\/.+?)['"]/g));
+        const matchResult = matches.map((match) => match[1]);
+        return matchResult;
+    }
+    static getComponent(componentPath, components) {
+        const parts = componentPath.split("/");
+        let current = components;
+        for (const part of parts) {
+            if (part === "#" || part === "components") {
+                continue;
+            }
+            current = current[part];
+            if (!current) {
+                return null;
+            }
+        }
+        return current;
+    }
+    static addComponent(componentName, usedComponentsSet, components) {
+        if (usedComponentsSet.has(componentName)) {
+            return;
+        }
+        usedComponentsSet.add(componentName);
+        const component = this.getComponent(componentName, components);
+        if (component) {
+            const componentString = JSON.stringify(component);
+            const componentReferences = SpecOptimizer.getComponentReferences(componentString);
+            for (const reference of componentReferences) {
+                this.addComponent(reference, usedComponentsSet, components);
+            }
+        }
+    }
+}
+SpecOptimizer.defaultOptions = {
+    removeUnusedComponents: true,
+    removeUnusedTags: true,
+    removeUserDefinedRootProperty: true,
+    removeUnusedSecuritySchemas: true,
+};
+
 // Copyright (c) Microsoft Corporation.
 class SpecFilter {
     static specFilter(filter, unResolveSpec, resolvedSpec, options) {
@@ -1180,7 +1335,7 @@ class SpecFilter {
                 }
             }
             newSpec.paths = newPaths;
-            return newSpec;
+            return SpecOptimizer.optimize(newSpec);
         }
         catch (err) {
             throw new SpecParserError(err.toString(), exports.ErrorType.FilterSpecFailed);
@@ -1303,7 +1458,7 @@ class AdaptiveCardGenerator {
                         {
                             type: "Image",
                             url: `\${${name}}`,
-                            $when: `\${${name} != null}`,
+                            $when: `\${${name} != null && ${name} != ''}`,
                         },
                     ];
                 }
@@ -1312,7 +1467,7 @@ class AdaptiveCardGenerator {
                         {
                             type: "Image",
                             url: "${$data}",
-                            $when: "${$data != null}",
+                            $when: "${$data != null && $data != ''}",
                         },
                     ];
                 }
@@ -1405,7 +1560,7 @@ function inferPreviewCardTemplate(card) {
         result.image = {
             url: `\${${inferredProperties.imageUrl}}`,
             alt: `\${if(${inferredProperties.imageUrl}, ${inferredProperties.imageUrl}, 'N/A')}`,
-            $when: `\${${inferredProperties.imageUrl} != null}`,
+            $when: `\${${inferredProperties.imageUrl} != null && ${inferredProperties.imageUrl} != ''}`,
         };
     }
     return result;