@rancher/shell 0.5.3 → 1.2.1

package/store/prefs.js

@@ -112,6 +112,9 @@ export const _RKE1 = 'rke1';
 export const _RKE2 = 'rke2';
 export const PROVISIONER = create('provisioner', _RKE2, { options: [_RKE1, _RKE2] });
 
+// Promo for Pod Security Policies (PSPs) being deprecated on kube version 1.25 on Cluster Dashboard page
+export const PSP_DEPRECATION_BANNER = create('hide-psp-deprecation-banner', false, { parseJSON });
+
 // Maximum number of clusters to show in the slide-in menu
 export const MENU_MAX_CLUSTERS = 10;
 // Prompt for confirm when scaling down node pool in GUI and save the pref
@@ -345,44 +348,46 @@ export const actions = {
     commit('cookiesLoaded');
   },
 
-  loadTheme({ dispatch }) {
-    const watchDark = window.matchMedia('(prefers-color-scheme: dark)');
-    const watchLight = window.matchMedia('(prefers-color-scheme: light)');
-    const watchNone = window.matchMedia('(prefers-color-scheme: no-preference)');
-
-    const interval = 30 * 60 * 1000;
-    const nextHalfHour = interval - Math.round(new Date().getTime()) % interval;
-
-    setTimeout(() => {
-      dispatch('loadTheme');
-    }, nextHalfHour);
-    // console.log('Update theme in', nextHalfHour, 'ms');
-
-    if ( watchDark.matches ) {
-      changed('dark');
-    } else if ( watchLight.matches ) {
-      changed('light');
-    } else {
-      changed(fromClock());
-    }
+  loadTheme({ state, dispatch }) {
+    if ( process.client ) {
+      const watchDark = window.matchMedia('(prefers-color-scheme: dark)');
+      const watchLight = window.matchMedia('(prefers-color-scheme: light)');
+      const watchNone = window.matchMedia('(prefers-color-scheme: no-preference)');
 
-    watchDark.addListener((e) => {
-      if ( e.matches ) {
-        changed('dark');
-      }
-    });
+      const interval = 30 * 60 * 1000;
+      const nextHalfHour = interval - Math.round(new Date().getTime()) % interval;
 
-    watchLight.addListener((e) => {
-      if ( e.matches ) {
-        changed('light');
-      }
-    });
+      setTimeout(() => {
+        dispatch('loadTheme');
+      }, nextHalfHour);
+      // console.log('Update theme in', nextHalfHour, 'ms');
 
-    watchNone.addListener((e) => {
-      if ( e.matches ) {
+      if ( watchDark.matches ) {
+        changed('dark');
+      } else if ( watchLight.matches ) {
+        changed('light');
+      } else {
         changed(fromClock());
       }
-    });
+
+      watchDark.addListener((e) => {
+        if ( e.matches ) {
+          changed('dark');
+        }
+      });
+
+      watchLight.addListener((e) => {
+        if ( e.matches ) {
+          changed('light');
+        }
+      });
+
+      watchNone.addListener((e) => {
+        if ( e.matches ) {
+          changed(fromClock());
+        }
+      });
+    }
 
     function changed(value) {
       // console.log('Prefers Theme:', value);

package/store/type-map.js

@@ -148,55 +148,17 @@ import isObject from 'lodash/isObject';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 import { sortBy } from '@shell/utils/sort';
 
-import { haveV1Monitoring, haveV2Monitoring } from '@shell/utils/monitoring';
+import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { NEU_VECTOR_NAMESPACE } from '@shell/config/product/neuvector';
 
 export const NAMESPACED = 'namespaced';
 export const CLUSTER_LEVEL = 'cluster';
 export const BOTH = 'both';
 
-export const TYPE_MODES = {
-  /**
-   * allTypes usage: All resource types
-   *
-   * getTree usage: Remove ignored schemas, resources not applicable to ns, etc
-   */
-  ALL:      'all',
-  /**
-   * Represents resource types that should be shown at the top of the side nav.
-   *
-   * For example all fixed resource types above `More Resources` in the cluster explorer
-   *
-   * These will always be shown in the side nav
-   *
-   * allTypes usage: Resources that are in a group
-   *
-   * getTree usage: Remove ignored schemas, resources not applicable to ns, etc
-   */
-  BASIC:    'basic',
-  /**
-   * Represents any type of resource type that has been favourited
-   *
-   * These will always be shown in the side nav.
-   *
-   * allTypes usage: Resource types that have been favorited
-   *
-   * getTree usage: Remove ignored schemas, resources not applicable to ns, etc
-   */
-  FAVORITE: 'favorite',
-  /**
-   * Represents no virtual or spoofed types that have a count.
-   *
-   * For example the `More Resource` in the cluster explorer
-   *
-   * These will be shown in the side nav if there are resources in the ns filter OR the resource is not namespaces
-   *
-   * allTypes usage: All resource types that are not virtual or spoofed
-   *
-   * getTree usage: Remove types with no counts. Remove ignored schemas, resources not applicable to ns, etc
-   */
-  USED:     'used',
-};
+export const ALL = 'all';
+export const BASIC = 'basic';
+export const FAVORITE = 'favorite';
+export const USED = 'used';
 
 export const ROOT = 'root';
 
@@ -209,7 +171,6 @@ const graphConfigMap = {};
 const FIELD_REGEX = /^\$\.metadata\.fields\[([0-9]*)\]/;
 
 export const IF_HAVE = {
-  V1_MONITORING:            'v1-monitoring',
   V2_MONITORING:            'v2-monitoring',
   PROJECT:                  'project',
   NO_PROJECT:               'no-project',
@@ -573,16 +534,17 @@ export const getters = {
   },
 
   getTree(state, getters, rootState, rootGetters) {
-    // Name the function so it's easily identifiable when performance tracing
-    return function getTree(productId, mode, allTypes, clusterId, namespaceMode, currentType, search) {
+    return (productId, mode, allTypes, clusterId, namespaceMode, namespaces, currentType, search) => {
       // getTree has four modes:
-      // - `basic` matches data types that should always be shown (even if there are 0 of them).
-      // - `used` matches the data types where there are more than 0 of them in the current set of namespaces.
+      // - `basic` matches data types that should always be shown even if there
+      //    are 0 of them.
+      // - `used` matches the data types where there are more than 0 of them
+      //    in the current set of namespaces.
       // - `all` matches all types.
       // - `favorite` matches starred types.
       // namespaceMode: 'namespaced', 'cluster', or 'both'
       // namespaces: null means all, otherwise it will be an array of specific namespaces to include
-      const isBasic = mode === TYPE_MODES.BASIC;
+      const isBasic = mode === BASIC;
 
       let searchRegex;
 
@@ -615,8 +577,7 @@ export const getters = {
           continue;
         }
 
-        const inStore = rootGetters.currentStore(typeObj.name);
-        const count = rootGetters[`${ inStore }/count`](typeObj);
+        const count = _matchingCounts(typeObj, namespaces);
         const groupForBasicType = getters.groupForBasicType(productId, typeObj.name);
 
         if ( typeObj.id === currentType ) {
@@ -624,7 +585,7 @@ export const getters = {
         } else if ( isBasic && !groupForBasicType ) {
           // If we want the basic tree only return basic types;
           continue;
-        } else if ( mode === TYPE_MODES.USED && count <= 0 ) {
+        } else if ( mode === USED && count <= 0 ) {
           // If there's none of this type, ignore this entry when viewing only in-use types
           // Note: count is sometimes null, which is <= 0.
           continue;
@@ -632,7 +593,7 @@ export const getters = {
 
         const label = typeObj.labelKey ? rootGetters['i18n/t'](typeObj.labelKey) || typeObj.label : typeObj.label;
 
-        const labelDisplay = highlightLabel(label, count, typeObj.schema);
+        const labelDisplay = highlightLabel(label, typeObj.count, typeObj.schema);
 
         if ( !labelDisplay ) {
           // Search happens in highlight and returns null if not found
@@ -643,10 +604,10 @@ export const getters = {
 
         if ( isBasic ) {
           group = _ensureGroup(root, groupForBasicType, true);
-        } else if ( mode === TYPE_MODES.FAVORITE ) {
+        } else if ( mode === FAVORITE ) {
           group = _ensureGroup(root, 'starred');
           group.weight = 1000;
-        } else if ( mode === TYPE_MODES.USED ) {
+        } else if ( mode === USED ) {
           group = _ensureGroup(root, `inUse::${ getters.groupLabelFor(typeObj.schema) }`);
         } else {
           group = _ensureGroup(root, typeObj.schema || typeObj.group || ROOT);
@@ -679,6 +640,7 @@ export const getters = {
           label,
           labelDisplay,
           mode:     typeObj.mode,
+          count,
           exact:    typeObj.exact || false,
           namespaced,
           route,
@@ -848,109 +810,69 @@ export const getters = {
     });
   },
 
-  /**
-   * Given many things, create a list of menu items per schema given the mode
-   */
   allTypes(state, getters, rootState, rootGetters) {
-    // Name the function so it's easily identifiable when performance tracing
-    return function allTypes(product, modes = [TYPE_MODES.ALL]) {
-      const module = state.products.find((p) => p.name === product)?.inStore;
+    return (product, mode = ALL) => {
+      const module = findBy(state.products, 'name', product)?.inStore;
       const schemas = rootGetters[`${ module }/all`](SCHEMA);
-      const isLocal = !rootGetters.currentCluster?.isLocal;
-      const isRancher = rootGetters.isRancher;
       const counts = rootGetters[`${ module }/all`](COUNT)?.[0]?.counts || {};
+      const isDev = rootGetters['prefs/get'](VIEW_IN_API);
+      const isBasic = mode === BASIC;
 
       const out = {};
 
-      // For performance reasons this must be super quick to iterate over.
-      // For each schema...
-      // 1) Determine if it's applicable given the mode
-      // 2) For each applicable mode create a `Type` entry
       for ( const schema of schemas ) {
-        let schemaModes = { };
-
-        modes.forEach((m) => {
-          schemaModes[m] = true;
-        });
-
         const attrs = schema.attributes || {};
+        const count = counts[schema.id];
+        const label = getters.labelFor(schema, count);
+        const weight = getters.typeWeightFor(schema?.id || label, isBasic);
         const typeOptions = getters['optionsFor'](schema);
 
-        schemaModes[TYPE_MODES.BASIC] = schemaModes[TYPE_MODES.BASIC] && getters.groupForBasicType(product, schema.id);
-
-        if (Object.values(schemaModes).every((s) => !s)) {
+        if ( isBasic ) {
+          // These are separate ifs so that things with no kind can still be basic
+          if ( !getters.groupForBasicType(product, schema.id) ) {
+            continue;
+          }
+        } else if ( mode === FAVORITE && !getters.isFavorite(schema.id) ) {
           continue;
-        }
-
-        schemaModes[TYPE_MODES.FAVORITE] = schemaModes[TYPE_MODES.FAVORITE] && getters.isFavorite(schema.id);
-
-        if (Object.values(schemaModes).every((s) => !s)) {
+        } else if ( !attrs.kind ) {
+          // Skip the schemas that aren't top-level types
+          continue;
+        } else if ( typeof typeOptions.ifRancherCluster !== 'undefined' && typeOptions.ifRancherCluster !== rootGetters.isRancher ) {
+          continue;
+        } else if (typeOptions.localOnly && !rootGetters.currentCluster?.isLocal) {
           continue;
         }
 
-        const onlyBasic = schemaModes[TYPE_MODES.BASIC] && modes.length === 1;
-
-        // This clause is only valid for non-basic modes. So if we have only basic... skip it
-        if (!onlyBasic) {
-          const invalidType = !attrs.kind ||
-          (typeof typeOptions.ifRancherCluster !== 'undefined' && typeOptions.ifRancherCluster !== isRancher) ||
-          (typeOptions.localOnly && isLocal);
-
-          if (invalidType) {
-            // Remove anything not basic
-            schemaModes = { [TYPE_MODES.BASIC]: schemaModes[TYPE_MODES.BASIC] };
-          }
-        }
-
-        // This is an expensive request to make, so only do it if we really need to
-        let label;
-
-        Object.entries(schemaModes).forEach(([mode, enabled]) => {
-          if (!enabled) {
-            return;
-          }
-
-          if (!out[mode]) {
-            out[mode] = {};
-          }
-
-          if (!label) {
-            label = getters.labelFor(schema, counts[schema.id]);
-          }
-
-          out[mode][schema.id] = {
-            label,
-            mode,
-            weight:     getters.typeWeightFor(schema?.id || label, mode === TYPE_MODES.BASIC),
-            schema,
-            name:       schema.id,
-            namespaced: typeOptions.namespaced === null ? attrs.namespaced : typeOptions.namespaced,
-            route:      typeOptions.customRoute
-          };
-        });
+        out[schema.id] = {
+          label,
+          mode,
+          weight,
+          schema,
+          name:        schema.id,
+          namespaced:  typeOptions.namespaced === null ? attrs.namespaced : typeOptions.namespaced,
+          count:       count ? count.summary.count || 0 : null,
+          byNamespace: count ? count.namespaces : {},
+          revision:    count ? count.revision : null,
+          route:       typeOptions.customRoute
+        };
       }
 
-      const nonUsedModes = modes.filter((m) => m !== TYPE_MODES.USED);
-      const isDev = rootGetters['prefs/get'](VIEW_IN_API);
-
       // Add virtual and spoofed types
-      if ( nonUsedModes.length ) {
+      if ( mode !== USED ) {
         const virtualTypes = state.virtualTypes[product] || [];
         const spoofedTypes = state.spoofedTypes[product] || [];
         const allTypes = [...virtualTypes, ...spoofedTypes];
-        const virtSpoofedModes = [...nonUsedModes];
 
         for ( const type of allTypes ) {
           const item = clone(type);
           const id = item.name;
+          const weight = type.weight || getters.typeWeightFor(item.label, isBasic);
 
           // Is there a virtual/spoofed type override for schema type?
           // Currently used by harvester, this should be investigated and removed if possible
-          virtSpoofedModes.forEach((mode) => {
-            if (out[mode]?.[id]) {
-              delete out[mode][id];
-            }
-          });
+          if (out[id]) {
+            delete out[id];
+          }
 
           if ( item['public'] === false && !isDev ) {
             continue;
@@ -989,17 +911,14 @@ export const getters = {
             continue;
           }
 
-          if (item.ifFeature && !rootGetters['features/get'](item.ifFeature)) {
+          if ( isBasic && !getters.groupForBasicType(product, id) ) {
+            continue;
+          } else if ( mode === FAVORITE && !getters.isFavorite(id) ) {
             continue;
           }
 
-          if (virtSpoofedModes.includes(TYPE_MODES.BASIC) && !getters.groupForBasicType(product, id) ) {
-            virtSpoofedModes.splice(virtSpoofedModes.indexOf(TYPE_MODES.BASIC), 1);
-          }
-
-          if (virtSpoofedModes.includes(TYPE_MODES.FAVORITE) && !getters.isFavorite(id) ) { // mode === TYPE_MODES.FAVORITE &&
-            virtSpoofedModes.splice(virtSpoofedModes.indexOf(TYPE_MODES.FAVORITE), 1);
-          }
+          item.mode = mode;
+          item.weight = weight;
 
           // Ensure labelKey is taken into account... with a mock count
           // This is harmless if the translation doesn't require count
@@ -1010,17 +929,7 @@ export const getters = {
             item.label = item.label || item.name;
           }
 
-          virtSpoofedModes.forEach((mode) => {
-            const isBasic = mode === TYPE_MODES.BASIC;
-            const weight = type.weight || getters.typeWeightFor(item.label, isBasic);
-
-            item.mode = mode;
-            item.weight = weight;
-            if (!out[mode]) {
-              out[mode] = {};
-            }
-            out[mode][id] = item;
-          });
+          out[id] = item;
         }
       }
 
@@ -1770,6 +1679,22 @@ function _sortGroup(tree, mode) {
   }
 }
 
+function _matchingCounts(typeObj, namespaces) {
+  // That was easy
+  if ( !typeObj.namespaced || !typeObj.byNamespace || namespaces === null || typeObj.count === null) {
+    return typeObj.count;
+  }
+
+  let out = 0;
+
+  // Otherwise start with 0 and count up
+  for ( const namespace of namespaces ) {
+    out += typeObj.byNamespace[namespace]?.count || 0;
+  }
+
+  return out;
+}
+
 function _applyMapping(objOrValue, mappings, keyField, cache, defaultFn) {
   let key = objOrValue;
   let found = false;
@@ -1863,9 +1788,6 @@ function ifHave(getters, option) {
   case IF_HAVE.V2_MONITORING: {
     return haveV2Monitoring(getters);
   }
-  case IF_HAVE.V1_MONITORING: {
-    return haveV1Monitoring(getters);
-  }
   case IF_HAVE.PROJECT: {
     return !!project(getters);
   }
@@ -1918,12 +1840,15 @@ function _rowValueGetter(col) {
   // We will use JsonPath to look up this value, which is costly - so if we can detect this format
   // Use a more efficient function to get the value
   const value = col.field.startsWith('.') ? `$${ col.field }` : col.field;
-  const found = value.match(FIELD_REGEX);
 
-  if (found && found.length === 2) {
-    const fieldIndex = parseInt(found[1], 10);
+  if (process.client) {
+    const found = value.match(FIELD_REGEX);
+
+    if (found && found.length === 2) {
+      const fieldIndex = parseInt(found[1], 10);
 
-    return (row) => row.metadata?.fields?.[fieldIndex];
+      return (row) => row.metadata?.fields?.[fieldIndex];
+    }
   }
 
   return value;

package/tsconfig.default.json

@@ -0,0 +1,46 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "lib": [
+      "ESNext",
+      "ESNext.AsyncIterable",
+      "DOM"
+    ],
+    "esModuleInterop": true,
+    "allowJs": true,
+    "sourceMap": true,
+    "strict": true,
+    "noEmit": false,
+    "baseUrl": ".",
+    "rootDir": ".",
+    "paths": {
+      "~/*": [
+        "../*"
+      ],
+      "@/*": [
+        "../*"
+      ],
+      "@shell/*": [
+        "../shell/*"
+      ],
+      "@pkg/*": [
+        "../shell/pkg/*"
+      ]
+    },
+    "typeRoots": [
+      "./node_modules/@types"
+    ],
+  },
+  "exclude": [
+    "node_modules",
+    ".nuxt",
+    "dist",
+    "dist-pkg",
+    "shell/creators",
+    "shell/scripts",
+    "script/standalone",
+    "docusaurus"
+  ]
+}

package/tsconfig.json

@@ -1,42 +1,16 @@
 {
-  "extends": "./tsconfig.paths.json",
+  "extends": "./tsconfig.default.json",
   "compilerOptions": {
-    "target": "ES2018",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "lib": [
-      "ESNext",
-      "ESNext.AsyncIterable",
-      "DOM"
-    ],
-    "allowJs": true,
-    "sourceMap": true,
-    "strict": true,
-    "noEmit": false,
-    "esModuleInterop": true,
-    "baseUrl": ".",
-    "rootDir": ".",
     "types": [
-      "node",
-      "jest",
-    ],
-    "typeRoots": [
-      "./node_modules/@types",
-      "../node_modules/@types"
-    ],
+      "@types/node",
+      "@types/jest",
+      "@nuxt/types",
+    ]
   },
   "exclude": [
-    "node_modules",
-    ".nuxt",
-    "dist",
-    "dist-pkg",
-    "../dist",
-    "../dist-pkg",
-    "../creators",
-    "../scripts",
-    "../cypress",
-    "../cypress.config.ts",
-    "../docusaurus",
-    "../**/*.spec.ts"
+    "cypress",
+    "./cypress.config.ts",
+    "**/*.test.ts",
+    "**/*.spec.ts"
   ]
 }