@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/utils/chart.js

@@ -1,6 +1,9 @@
 import semver from 'semver';
 import { compare } from '@shell/utils/version';
 import { compatibleVersionsFor } from '@shell/store/catalog';
+import {
+  CHART, REPO, REPO_TYPE, VERSION, DEPRECATED
+} from '@shell/config/query-params';
 
 /**
  * Compares two chart versions using SemVer logic, with special handling for Rancher's "up" build metadata.
@@ -80,3 +83,36 @@ export function getLatestCompatibleVersion(chart, workerOSs, showPrerelease) {
 
   return (compatible.length ? compatible[0] : chart.versions[0]) || {};
 }
+
+/**
+ * Builds the route URL for the standalone chart readme page.
+ *
+ * The helper maps chart context into query params so the readme page can fetch
+ * version info directly (instead of relying on local/session storage transfer).
+ */
+export function getStandaloneReadmeUrl(router, {
+  cluster,
+  repoType,
+  repoName,
+  chartName,
+  versionName,
+  deprecated,
+  showAppReadme = true,
+  hideReadmeFirstTitle = true,
+} = {}) {
+  const { href } = router.resolve({
+    name:   'readme',
+    params: { cluster },
+    query:  {
+      [REPO_TYPE]:          repoType,
+      [REPO]:               repoName,
+      [CHART]:              chartName,
+      [VERSION]:            versionName,
+      [DEPRECATED]:         deprecated,
+      showAppReadme:        String(showAppReadme),
+      hideReadmeFirstTitle: String(hideReadmeFirstTitle),
+    }
+  });
+
+  return href;
+}

package/utils/crypto/__tests__/browserHashUtils.test.ts

@@ -0,0 +1,98 @@
+import { hashObj, isEmptyData, convertToBuffer } from '../browserHashUtils';
+
+describe('crypto/browserHashUtils', () => {
+  describe('hashObj', () => {
+    it.each([
+      {
+        desc:     'empty object',
+        input:    {},
+        expected: '31e',
+      },
+      {
+        desc:     'object with string value',
+        input:    { a: 1 },
+        expected: '1b0fmfe',
+      },
+    ])('returns deterministic base-36 hash for $desc', ({ input, expected }) => {
+      expect(hashObj(input)).toStrictEqual(expected);
+    });
+
+    it('is idempotent — same input always produces same hash', () => {
+      const obj = {
+        a: 1, b: 'hello', c: [1, 2, 3]
+      };
+
+      expect(hashObj(obj)).toStrictEqual(hashObj(obj));
+    });
+
+    it('produces different hashes for different objects', () => {
+      expect(hashObj({ a: 1 })).not.toStrictEqual(hashObj({ b: 1 }));
+    });
+
+    it('returns a base-36 string (only digits and lowercase a-z)', () => {
+      expect(hashObj({ key: 'value' })).toMatch(/^[0-9a-z]+$/);
+    });
+  });
+
+  describe('isEmptyData', () => {
+    it.each([
+      {
+        desc:     'empty string',
+        input:    '',
+        expected: true,
+      },
+      {
+        desc:     'non-empty string',
+        input:    'hello',
+        expected: false,
+      },
+      {
+        desc:     'zero-length ArrayBuffer',
+        input:    new ArrayBuffer(0),
+        expected: true,
+      },
+      {
+        desc:     'non-empty ArrayBuffer',
+        input:    new ArrayBuffer(5),
+        expected: false,
+      },
+      {
+        desc:     'zero-length Uint8Array',
+        input:    new Uint8Array(0),
+        expected: true,
+      },
+      {
+        desc:     'non-empty Uint8Array',
+        input:    new Uint8Array([1, 2, 3]),
+        expected: false,
+      },
+    ])('$desc → $expected', ({ input, expected }) => {
+      expect(isEmptyData(input)).toStrictEqual(expected);
+    });
+  });
+
+  describe('convertToBuffer', () => {
+    it('converts a string to a Uint8Array with the correct byte values', () => {
+      const result = convertToBuffer('hello');
+
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(Array.from(result)).toStrictEqual([104, 101, 108, 108, 111]);
+    });
+
+    it('converts a Uint8Array view to a Uint8Array with the same bytes', () => {
+      const input = new Uint8Array([1, 2, 3]);
+      const result = convertToBuffer(input);
+
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(Array.from(result)).toStrictEqual([1, 2, 3]);
+    });
+
+    it('wraps a plain ArrayBuffer in a Uint8Array', () => {
+      const buf = new Uint8Array([10, 20, 30]).buffer;
+      const result = convertToBuffer(buf);
+
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(Array.from(result)).toStrictEqual([10, 20, 30]);
+    });
+  });
+});

package/utils/crypto/__tests__/index.test.ts

@@ -0,0 +1,144 @@
+import { base64Encode, base64DecodeToBuffer, base64Decode, binarySize } from '../index';
+
+describe('crypto/index', () => {
+  describe('base64Encode', () => {
+    it.each([
+      {
+        desc:     'null input',
+        input:    null as any,
+        expected: null,
+      },
+      {
+        desc:     'undefined input',
+        input:    undefined as any,
+        expected: undefined,
+      },
+      {
+        desc:     'empty string',
+        input:    '',
+        expected: '',
+      },
+      {
+        desc:     'hello',
+        input:    'hello',
+        expected: 'aGVsbG8=',
+      },
+      {
+        desc:     'abc (no padding needed)',
+        input:    'abc',
+        expected: 'YWJj',
+      },
+    ])('returns correct base64 for $desc', ({ input, expected }) => {
+      expect(base64Encode(input)).toStrictEqual(expected);
+    });
+
+    it.each([
+      {
+        desc:     'single-byte input (strips two padding chars)',
+        input:    'a',
+        expected: 'YQ',
+      },
+      {
+        desc:     'two-byte input (strips one padding char)',
+        input:    'ab',
+        expected: 'YWI',
+      },
+      {
+        desc:     'three-byte input (no padding to strip)',
+        input:    'abc',
+        expected: 'YWJj',
+      },
+    ])('url alphabet: $desc', ({ input, expected }) => {
+      expect(base64Encode(input, 'url')).toStrictEqual(expected);
+    });
+  });
+
+  describe('base64DecodeToBuffer', () => {
+    it.each([
+      {
+        desc:     'null',
+        input:    null as any,
+        expected: null,
+      },
+      {
+        desc:     'undefined',
+        input:    undefined as any,
+        expected: undefined,
+      },
+    ])('returns $desc unchanged', ({ input, expected }) => {
+      expect(base64DecodeToBuffer(input)).toStrictEqual(expected);
+    });
+
+    it('decodes a valid base64 string to a buffer', () => {
+      const result = base64DecodeToBuffer('aGVsbG8=');
+
+      expect(result.toString()).toStrictEqual('hello');
+    });
+
+    it('decodes base64 without padding', () => {
+      const result = base64DecodeToBuffer('YWJj');
+
+      expect(result.toString()).toStrictEqual('abc');
+    });
+  });
+
+  describe('base64Decode', () => {
+    it.each([
+      {
+        desc:     'null',
+        input:    null as any,
+        expected: null,
+      },
+      {
+        desc:     'empty string',
+        input:    '',
+        expected: '',
+      },
+      {
+        desc:     'padded base64 for hello',
+        input:    'aGVsbG8=',
+        expected: 'hello',
+      },
+      {
+        desc:     'unpadded base64 for abc',
+        input:    'YWJj',
+        expected: 'abc',
+      },
+    ])('$desc', ({ input, expected }) => {
+      expect(base64Decode(input)).toStrictEqual(expected);
+    });
+
+    it('decodes url-safe base64 without padding (url-encoded "a")', () => {
+      // base64Encode('a', 'url') → 'YQ' (stripped ==)
+      // base64Decode must handle missing padding
+      expect(base64Decode('YQ')).toStrictEqual('a');
+    });
+  });
+
+  describe('binarySize', () => {
+    it.each([
+      {
+        desc:     'empty string',
+        input:    '',
+        expected: 0,
+      },
+      {
+        desc:     'no padding (3 bytes — "abc")',
+        input:    'YWJj',
+        expected: 3,
+      },
+      {
+        desc:     'one padding char (2 bytes — "ab")',
+        input:    'YWI=',
+        expected: 2,
+      },
+      {
+        desc:     'two padding chars (1 byte — "a")',
+        input:    'YQ==',
+        expected: 1,
+      },
+    ])('$desc → $expected bytes', ({ input, expected }) => {
+      expect(binarySize(input)).toStrictEqual(expected);
+    });
+  });
+});

package/utils/duration.ts

@@ -0,0 +1,104 @@
+export const SECONDS_PER = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+} as const;
+
+export const UNIT_TO_MS = {
+  ms: 1,
+  s:  1000,
+  m:  60 * 1000,
+  h:  60 * 60 * 1000,
+  d:  24 * 60 * 60 * 1000,
+  w:  7 * 24 * 60 * 60 * 1000,
+  y:  365 * 24 * 60 * 60 * 1000
+} as const;
+
+const DURATION_REGEX = /^(?:([0-9]+)y)?(?:([0-9]+)w)?(?:([0-9]+)d)?(?:([0-9]+)h)?(?:([0-9]+)m)?(?:([0-9]+)s)?(?:([0-9]+)ms)?$/;
+
+export function toMilliseconds(input: string | number | null | undefined): number {
+  if (!input) {
+    return 0;
+  }
+  const d = `${ input }`.match(DURATION_REGEX);
+
+  if (d) {
+    const properties = d.slice(1);
+    const numberD = properties.map((value) => ([null, undefined].includes(value) ? 0 : Number(value)));
+    const data: Record<string, number> = {};
+
+    [
+      data.y,
+      data.w,
+      data.d,
+      data.h,
+      data.m,
+      data.s,
+      data.ms
+    ] = numberD;
+
+    return Object.keys(data).reduce((total, unit) => (total + ((data[unit] || 0) * (UNIT_TO_MS[unit as keyof typeof UNIT_TO_MS] || 0))), 0);
+  }
+
+  return 0;
+}
+
+export function toSeconds(input: string | number | null | undefined): number {
+  return Math.floor(toMilliseconds(input) / 1000);
+}
+
+const DURATION_UNITS = [
+  { divisor: SECONDS_PER.d, suffix: 'd' },
+  { divisor: SECONDS_PER.h, suffix: 'h' },
+  { divisor: SECONDS_PER.m, suffix: 'm' },
+  { divisor: SECONDS_PER.s, suffix: 's' },
+];
+
+/**
+ * Decomposes a total number of seconds into the largest whole time unit.
+ * For example, 7200 returns { value: 2, unit: 3600 } (2 hours).
+ * @param seconds - Total seconds to decompose
+ * @returns An object with `value` (the count) and `unit` (the multiplier in seconds: 86400, 3600, 60, or 1)
+ */
+export function secondsToLargestUnit(seconds: number): { value: number, unit: number } {
+  if (seconds <= 0) {
+    return { value: seconds, unit: SECONDS_PER.s };
+  }
+
+  if (seconds % SECONDS_PER.d === 0) {
+    return { value: seconds / SECONDS_PER.d, unit: SECONDS_PER.d };
+  }
+  if (seconds % SECONDS_PER.h === 0) {
+    return { value: seconds / SECONDS_PER.h, unit: SECONDS_PER.h };
+  }
+  if (seconds % SECONDS_PER.m === 0) {
+    return { value: seconds / SECONDS_PER.m, unit: SECONDS_PER.m };
+  }
+
+  return { value: seconds, unit: SECONDS_PER.s };
+}
+
+/**
+ * Formats a duration in seconds into a human-readable string (e.g. "1d 3h 46m 40s").
+ * Zero-value components are omitted. Returns "0s" for non-positive values.
+ * @param seconds - Duration in seconds
+ */
+export function formatDuration(seconds: number): string {
+  if (seconds <= 0) {
+    return '0s';
+  }
+
+  let remaining = seconds;
+
+  return DURATION_UNITS
+    .map(({ divisor, suffix }) => {
+      const count = Math.floor(remaining / divisor);
+
+      remaining %= divisor;
+
+      return count > 0 ? `${ count }${ suffix }` : '';
+    })
+    .filter(Boolean)
+    .join(' ');
+}

package/utils/dynamic-content/__tests__/notification-handler.test.ts

@@ -0,0 +1,196 @@
+import { Notification } from '@shell/types/notifications';
+import { READ_ANNOUNCEMENTS } from '@shell/store/prefs';
+import { createHandler, DynamicContentAnnouncementHandlerName } from '../notification-handler';
+import { ANNOUNCEMENT_PREFIX } from '../announcement';
+
+function makeStore(prefValue: string, notificationsAll: any[] = []) {
+  const dispatch = jest.fn();
+  const store = {
+    getters: {
+      'notifications/all': notificationsAll,
+      'prefs/get':         jest.fn().mockReturnValue(prefValue),
+    },
+    dispatch,
+  };
+
+  return { store, dispatch };
+}
+
+function makeNotification(id: string): Notification {
+  return {
+    id,
+    level:   0,
+    title:   'Test',
+    message: '',
+  };
+}
+
+describe('notification-handler', () => {
+  describe('DynamicContentAnnouncementHandlerName', () => {
+    it('has the expected constant value', () => {
+      expect(DynamicContentAnnouncementHandlerName).toStrictEqual('dc-announcements');
+    });
+  });
+
+  describe('createHandler', () => {
+    it('returns an object with an onReadUpdated method', () => {
+      const { store } = makeStore('');
+      const handler = createHandler(store);
+
+      expect(typeof handler.onReadUpdated).toStrictEqual('function');
+    });
+
+    describe('onReadUpdated', () => {
+      describe('non-announcement notifications', () => {
+        it.each([
+          {
+            desc: 'arbitrary id',
+            id:   'some-notification-id',
+          },
+          {
+            desc: 'empty id',
+            id:   '',
+          },
+          {
+            desc: 'id with announcement substring but not prefix',
+            id:   `not-${ ANNOUNCEMENT_PREFIX }foo`,
+          },
+        ])('does not dispatch when notification id is "$id" ($desc)', async({ id }) => {
+          const { store, dispatch } = makeStore('');
+          const handler = createHandler(store);
+
+          await handler.onReadUpdated(makeNotification(id), true);
+
+          expect(dispatch).not.toHaveBeenCalled();
+        });
+      });
+
+      describe('marking announcement as read (read=true)', () => {
+        it.each([
+          {
+            desc:           'empty pref stores single id',
+            prefValue:      '',
+            announcementId: 'foo',
+            expected:       'foo',
+          },
+          {
+            desc:           'pref with other values adds id sorted',
+            prefValue:      'abc,xyz',
+            announcementId: 'bar',
+            expected:       'abc,bar,xyz',
+          },
+          {
+            desc:           'id already present is not duplicated',
+            prefValue:      'foo',
+            announcementId: 'foo',
+            expected:       'foo',
+          },
+          {
+            desc:           'new value sorts into correct lexicographic position',
+            prefValue:      'alpha,zeta',
+            announcementId: 'beta',
+            expected:       'alpha,beta,zeta',
+          },
+          {
+            desc:           'single char id added to empty pref',
+            prefValue:      '',
+            announcementId: 'a',
+            expected:       'a',
+          },
+        ])('$desc', async({ prefValue, announcementId, expected }) => {
+          const { store, dispatch } = makeStore(prefValue);
+          const handler = createHandler(store);
+          const notification = makeNotification(`${ ANNOUNCEMENT_PREFIX }${ announcementId }`);
+
+          await handler.onReadUpdated(notification, true);
+
+          expect(dispatch).toHaveBeenCalledWith('prefs/set', {
+            key:   READ_ANNOUNCEMENTS,
+            value: expected,
+          });
+        });
+      });
+
+      describe('marking announcement as unread (read=false)', () => {
+        it.each([
+          {
+            desc:           'id in pref is removed',
+            prefValue:      'foo',
+            announcementId: 'foo',
+            expected:       '',
+          },
+          {
+            desc:           'id in multi-value pref is removed leaving others',
+            prefValue:      'bar,foo,xyz',
+            announcementId: 'foo',
+            expected:       'bar,xyz',
+          },
+          {
+            desc:           'id not in pref leaves pref unchanged',
+            prefValue:      'bar,baz',
+            announcementId: 'foo',
+            expected:       'bar,baz',
+          },
+          {
+            desc:           'empty pref dispatches empty string',
+            prefValue:      '',
+            announcementId: 'foo',
+            expected:       '',
+          },
+        ])('$desc', async({ prefValue, announcementId, expected }) => {
+          const { store, dispatch } = makeStore(prefValue);
+          const handler = createHandler(store);
+          const notification = makeNotification(`${ ANNOUNCEMENT_PREFIX }${ announcementId }`);
+
+          await handler.onReadUpdated(notification, false);
+
+          expect(dispatch).toHaveBeenCalledWith('prefs/set', {
+            key:   READ_ANNOUNCEMENTS,
+            value: expected,
+          });
+        });
+      });
+
+      describe('dispatch call details', () => {
+        it('uses READ_ANNOUNCEMENTS as the preference key', async() => {
+          const { store, dispatch } = makeStore('');
+          const handler = createHandler(store);
+
+          await handler.onReadUpdated(makeNotification(`${ ANNOUNCEMENT_PREFIX }test-id`), true);
+
+          expect(dispatch).toHaveBeenCalledWith('prefs/set', expect.objectContaining({ key: READ_ANNOUNCEMENTS }));
+        });
+
+        it('strips the announcement prefix from the stored id', async() => {
+          const { store, dispatch } = makeStore('');
+          const handler = createHandler(store);
+
+          await handler.onReadUpdated(makeNotification(`${ ANNOUNCEMENT_PREFIX }my-announcement`), true);
+
+          expect(dispatch).toHaveBeenCalledWith('prefs/set', {
+            key:   READ_ANNOUNCEMENTS,
+            value: 'my-announcement',
+          });
+        });
+      });
+
+      describe('interaction with existing notifications', () => {
+        it('calls notifications/all getter to retrieve current announcements', async() => {
+          const notificationsAll = [
+            { id: `${ ANNOUNCEMENT_PREFIX }existing` },
+            { id: 'other-notification' },
+          ];
+          const { store, dispatch } = makeStore('existing', notificationsAll);
+          const handler = createHandler(store);
+
+          await handler.onReadUpdated(makeNotification(`${ ANNOUNCEMENT_PREFIX }new`), true);
+
+          expect(dispatch).toHaveBeenCalledWith('prefs/set', {
+            key:   READ_ANNOUNCEMENTS,
+            value: 'existing,new',
+          });
+        });
+      });
+    });
+  });
+});

package/utils/dynamic-content/info.ts

@@ -24,7 +24,8 @@ const SUSE_EXTENSIONS = [
   'neuvector-ui-ext',
   'observability',
   'supportability-review-app',
-  'virtual-clusters'
+  'virtual-clusters',
+  'rancher-ai-ui'
 ];
 
 type FeatureFlagInfos = {

package/utils/error.js

@@ -1,5 +1,6 @@
 import { isArray } from '@shell/utils/array';
 const AWS_SDK_UNHANDLED_ERROR = 'Deserialization error:';
+const DO_NOT_LOG_ERROR = '__doNotLogError';
 
 export class ClusterNotFoundError extends Error {
   static NAME = 'ClusterNotFoundError'
@@ -106,6 +107,18 @@ export function exceptionToErrorsArray(err) {
   }
 }
 
+export function createDoNotLogError(message) {
+  const err = new Error(message);
+
+  err[DO_NOT_LOG_ERROR] = true;
+
+  return err;
+}
+
+export function isDoNotLogError(err) {
+  return !!(err?.[DO_NOT_LOG_ERROR] || err?.doNotLog);
+}
+
 /**
  * Imported from path-to-regexp
  * @param {*} err