@autoguru/overdrive 4.45.2 → 4.47.0

package/dist/utils/css.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import { cssVarUnwrap, getThemeTokenValue } from "./css.js";
+describe('css utilities', () => {
+  describe('cssVarUnwrap', () => {
+    it('extracts CSS variable name from var() function', () => {
+      expect(cssVarUnwrap('var(--color-primary)')).toBe('--color-primary');
+      expect(cssVarUnwrap('var(--spacing-2)')).toBe('--spacing-2');
+      expect(cssVarUnwrap('var(--border-radius, 4px)')).toBe('--border-radius, 4px');
+    });
+    it('returns original value if not a CSS variable', () => {
+      expect(cssVarUnwrap('#ff0000')).toBe('#ff0000');
+      expect(cssVarUnwrap('16px')).toBe('16px');
+      expect(cssVarUnwrap('solid')).toBe('solid');
+    });
+    it('handles edge cases', () => {
+      expect(cssVarUnwrap('')).toBe('');
+      expect(cssVarUnwrap('var()')).toBe('var()');
+      expect(cssVarUnwrap('var')).toBe('var');
+    });
+  });
+  describe('getThemeTokenValue', () => {
+    beforeEach(() => {
+      // Clean up any existing test elements
+      document.querySelectorAll('.test-theme').forEach(el => el.remove());
+    });
+    afterEach(() => {
+      // Clean up test elements
+      document.querySelectorAll('.test-theme').forEach(el => el.remove());
+    });
+    it('returns empty string when themeClass is null/undefined', () => {
+      expect(getThemeTokenValue(null, '--color-primary')).toBe('');
+      expect(getThemeTokenValue(undefined, '--color-primary')).toBe('');
+    });
+    it('returns empty string when token is null/undefined', () => {
+      expect(getThemeTokenValue('theme-class', null)).toBe('');
+      expect(getThemeTokenValue('theme-class')).toBe('');
+    });
+    it('returns empty string when element is not found', () => {
+      expect(getThemeTokenValue('non-existent-theme', '--color-primary')).toBe('');
+    });
+    it('returns CSS custom property value from themed element', () => {
+      // Create a test element with CSS custom properties
+      const testElement = document.createElement('div');
+      testElement.className = 'test-theme';
+      testElement.style.setProperty('--color-primary', '#ff0000');
+      testElement.style.setProperty('--spacing-large', '24px');
+      document.body.append(testElement);
+      expect(getThemeTokenValue('test-theme', 'var(--color-primary)')).toBe('#ff0000');
+      expect(getThemeTokenValue('test-theme', '--spacing-large')).toBe('24px');
+    });
+    it('trims whitespace from computed values', () => {
+      const testElement = document.createElement('div');
+      testElement.className = 'test-theme';
+      testElement.style.setProperty('--color-with-spaces', '  #ff0000  ');
+      document.body.append(testElement);
+      expect(getThemeTokenValue('test-theme', '--color-with-spaces')).toBe('#ff0000');
+    });
+    it('returns empty string for non-existent CSS variables', () => {
+      const testElement = document.createElement('div');
+      testElement.className = 'test-theme';
+      document.body.append(testElement);
+      expect(getThemeTokenValue('test-theme', '--non-existent-var')).toBe('');
+    });
+  });
+});

package/dist/utils/dateFormat.d.ts

@@ -0,0 +1,24 @@
+import { type DateValue } from '@internationalized/date';
+/**
+ * Checks if a given DateValue represents today's date
+ * @param dateValue
+ * @returns boolean
+ */
+export declare function isToday(date: DateValue | string | null | undefined): boolean;
+/**
+ * Formats a date value or ISO date string for display, with special handling for "today"
+ *
+ * @param date - DateValue, ISO date string, or null/undefined
+ * @param format - Intl date formatting style (default: 'medium')
+ * @param locales - Locales for formatting (default: 'en-AU')
+ * @returns Formatted date string or empty string for null/undefined
+ *
+ * @example
+ * ```ts
+ * displayFormattedDate('2025-05-01') // "May 01, 2025"
+ * displayFormattedDate('2024-01-15', 'full') // "Monday, January 15, 2024"
+ * displayFormattedDate('2025-09-21', 'short') // "21/9/25"
+ * ```
+ */
+export declare function displayFormattedDate(date: DateValue | string | null | undefined, format?: Intl.DateTimeFormatOptions['dateStyle'], locales?: Intl.LocalesArgument): string;
+//# sourceMappingURL=dateFormat.d.ts.map

package/dist/utils/dateFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateFormat.d.ts","sourceRoot":"","sources":["../../lib/utils/dateFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EAIN,KAAK,SAAS,EACd,MAAM,yBAAyB,CAAC;AAEjC;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,WAUlE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAC3C,MAAM,GAAE,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAY,EAC1D,OAAO,GAAE,IAAI,CAAC,eAAyB,GACrC,MAAM,CAmBR"}

package/dist/utils/dateFormat.js

@@ -0,0 +1,57 @@
+"use strict";
+
+import { getLocalTimeZone, parseDate, today } from '@internationalized/date';
+
+/**
+ * Checks if a given DateValue represents today's date
+ * @param dateValue
+ * @returns boolean
+ */
+export function isToday(date) {
+  if (!date) return false;
+  if (typeof date === 'string') {
+    try {
+      date = parseDate(date);
+    } catch {
+      return false;
+    }
+  }
+  return date.compare(today(getLocalTimeZone())) === 0;
+}
+
+/**
+ * Formats a date value or ISO date string for display, with special handling for "today"
+ *
+ * @param date - DateValue, ISO date string, or null/undefined
+ * @param format - Intl date formatting style (default: 'medium')
+ * @param locales - Locales for formatting (default: 'en-AU')
+ * @returns Formatted date string or empty string for null/undefined
+ *
+ * @example
+ * ```ts
+ * displayFormattedDate('2025-05-01') // "May 01, 2025"
+ * displayFormattedDate('2024-01-15', 'full') // "Monday, January 15, 2024"
+ * displayFormattedDate('2025-09-21', 'short') // "21/9/25"
+ * ```
+ */
+export function displayFormattedDate(date, format = 'medium', locales = 'en-AU') {
+  if (!date) return '';
+  let dateValue;
+
+  // Handle string input by parsing it
+  if (typeof date === 'string') {
+    try {
+      dateValue = parseDate(date);
+    } catch {
+      return date; // Return original string if parsing fails
+    }
+  } else {
+    dateValue = date;
+  }
+
+  // Format the date using Intl.DateTimeFormat
+  const formatter = new Intl.DateTimeFormat(locales, {
+    dateStyle: format
+  });
+  return formatter.format(dateValue.toDate(getLocalTimeZone()));
+}

package/dist/utils/object.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=object.spec.d.ts.map

package/dist/utils/object.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.spec.d.ts","sourceRoot":"","sources":["../../lib/utils/object.spec.ts"],"names":[],"mappings":""}

package/dist/utils/object.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+
+import { arrayFromKeys } from "./object.js";
+describe('object utilities', () => {
+  describe('arrayFromKeys', () => {
+    it('returns array of object keys with proper typing', () => {
+      const testObj = {
+        name: 'John',
+        age: 30,
+        active: true
+      };
+      const keys = arrayFromKeys(testObj);
+      expect(keys).toEqual(['name', 'age', 'active']);
+      expect(keys).toHaveLength(3);
+    });
+    it('works with empty objects', () => {
+      const emptyObj = {};
+      const keys = arrayFromKeys(emptyObj);
+      expect(keys).toEqual([]);
+      expect(keys).toHaveLength(0);
+    });
+    it('preserves key order', () => {
+      const orderedObj = {
+        first: 1,
+        second: 2,
+        third: 3,
+        fourth: 4
+      };
+      const keys = arrayFromKeys(orderedObj);
+      expect(keys).toEqual(['first', 'second', 'third', 'fourth']);
+    });
+    it('works with objects containing different value types', () => {
+      const mixedObj = {
+        string: 'text',
+        number: 42,
+        boolean: false,
+        array: [1, 2, 3],
+        object: {
+          nested: true
+        },
+        nullValue: null,
+        undefinedValue: undefined,
+        functionValue: () => {}
+      };
+      const keys = arrayFromKeys(mixedObj);
+      expect(keys).toEqual(['string', 'number', 'boolean', 'array', 'object', 'nullValue', 'undefinedValue', 'functionValue']);
+      expect(keys).toHaveLength(8);
+    });
+    it('works with objects having symbol keys (should be excluded)', () => {
+      const symbolKey = Symbol('test');
+      const objWithSymbol = {
+        normalKey: 'value',
+        [symbolKey]: 'symbol value'
+      };
+      const keys = arrayFromKeys(objWithSymbol);
+
+      // Object.keys() only returns enumerable string keys, not symbols
+      expect(keys).toEqual(['normalKey']);
+      expect(keys).toHaveLength(1);
+    });
+    it('works with objects having numeric string keys', () => {
+      const numericKeysObj = {
+        '0': 'zero',
+        '1': 'one',
+        '10': 'ten',
+        '2': 'two'
+      };
+      const keys = arrayFromKeys(numericKeysObj);
+
+      // Object.keys() returns numeric keys in ascending order, then other keys
+      expect(keys).toEqual(['0', '1', '2', '10']);
+      expect(keys).toHaveLength(4);
+    });
+    it('works with objects created with null prototype', () => {
+      const nullProtoObj = Object.create(null);
+      nullProtoObj.key1 = 'value1';
+      nullProtoObj.key2 = 'value2';
+      const keys = arrayFromKeys(nullProtoObj);
+      expect(keys).toEqual(['key1', 'key2']);
+      expect(keys).toHaveLength(2);
+    });
+    it('ignores inherited properties', () => {
+      // Create a prototype object
+      const proto = {
+        inheritedProp: 'inherited'
+      };
+
+      // Create object that inherits from proto
+      const obj = Object.create(proto);
+      obj.ownProp1 = 'own1';
+      obj.ownProp2 = 'own2';
+      const keys = arrayFromKeys(obj);
+
+      // Should only include own properties, not inherited ones
+      expect(keys).toEqual(['ownProp1', 'ownProp2']);
+      expect(keys).toHaveLength(2);
+    });
+    it('works with array-like objects', () => {
+      const arrayLikeObj = {
+        '0': 'a',
+        '1': 'b',
+        '2': 'c',
+        length: 3
+      };
+      const keys = arrayFromKeys(arrayLikeObj);
+
+      // Array-like objects have numeric string keys + length
+      expect(keys).toEqual(['0', '1', '2', 'length']);
+      expect(keys).toHaveLength(4);
+    });
+    it('maintains type safety with specific object types', () => {
+      const typedObj = {
+        prop1: 'test',
+        prop2: 123
+      };
+      const keys = arrayFromKeys(typedObj);
+
+      // TypeScript should infer the correct key type
+      expect(keys).toEqual(['prop1', 'prop2']);
+
+      // This ensures the return type is properly typed
+      const firstKey = keys[0]; // Should be string
+      expect(['prop1', 'prop2']).toContain(firstKey);
+    });
+    it('works with readonly objects', () => {
+      const readonlyObj = {
+        readonly1: 'value1',
+        readonly2: 'value2'
+      };
+      const keys = arrayFromKeys(readonlyObj);
+      expect(keys).toEqual(['readonly1', 'readonly2']);
+      expect(keys).toHaveLength(2);
+    });
+  });
+});

package/dist/utils/responsiveStyle.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=responsiveStyle.spec.d.ts.map

package/dist/utils/responsiveStyle.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responsiveStyle.spec.d.ts","sourceRoot":"","sources":["../../lib/utils/responsiveStyle.spec.ts"],"names":[],"mappings":""}

package/dist/utils/responsiveStyle.spec.js

@@ -0,0 +1,134 @@
+"use strict";
+
+import { describe, expect, it } from 'vitest';
+import { responsiveStyle } from "./responsiveStyle.js";
+describe('responsiveStyle', () => {
+  it('applies mobile styles directly', () => {
+    const result = responsiveStyle({
+      mobile: {
+        color: 'red',
+        fontSize: '16px'
+      }
+    });
+    expect(result).toEqual({
+      color: 'red',
+      fontSize: '16px'
+    });
+  });
+  it('wraps non-mobile styles in media queries', () => {
+    const result = responsiveStyle({
+      tablet: {
+        color: 'blue'
+      }
+    });
+    expect(result).toEqual({
+      '@media': {
+        'screen and (min-width: 768px)': {
+          color: 'blue'
+        }
+      }
+    });
+  });
+  it('combines mobile and responsive styles', () => {
+    const result = responsiveStyle({
+      mobile: {
+        color: 'red',
+        fontSize: '14px'
+      },
+      tablet: {
+        fontSize: '16px'
+      },
+      desktop: {
+        color: 'blue'
+      }
+    });
+    expect(result).toEqual({
+      color: 'red',
+      fontSize: '14px',
+      '@media': {
+        'screen and (min-width: 768px)': {
+          fontSize: '16px'
+        },
+        'screen and (min-width: 1024px)': {
+          color: 'blue'
+        }
+      }
+    });
+  });
+  it('handles multiple media queries', () => {
+    const result = responsiveStyle({
+      tablet: {
+        padding: '16px'
+      },
+      desktop: {
+        padding: '24px'
+      },
+      largeDesktop: {
+        padding: '32px'
+      }
+    });
+    expect(result).toEqual({
+      '@media': {
+        'screen and (min-width: 768px)': {
+          padding: '16px'
+        },
+        'screen and (min-width: 1024px)': {
+          padding: '24px'
+        },
+        'screen and (min-width: 1920px)': {
+          padding: '32px'
+        }
+      }
+    });
+  });
+  it('handles empty input', () => {
+    const result = responsiveStyle({});
+    expect(result).toEqual({});
+  });
+  it('handles only mobile styles', () => {
+    const result = responsiveStyle({
+      mobile: {
+        margin: '8px',
+        padding: '4px'
+      }
+    });
+    expect(result).toEqual({
+      margin: '8px',
+      padding: '4px'
+    });
+  });
+  it('handles only responsive styles', () => {
+    const result = responsiveStyle({
+      desktop: {
+        maxWidth: '1200px'
+      }
+    });
+    expect(result).toEqual({
+      '@media': {
+        'screen and (min-width: 1024px)': {
+          maxWidth: '1200px'
+        }
+      }
+    });
+  });
+  it('preserves complex style values', () => {
+    const result = responsiveStyle({
+      mobile: {
+        background: 'linear-gradient(to right, red, blue)',
+        transform: 'translateX(10px) scale(1.2)'
+      },
+      tablet: {
+        background: 'radial-gradient(circle, green, yellow)'
+      }
+    });
+    expect(result).toEqual({
+      background: 'linear-gradient(to right, red, blue)',
+      transform: 'translateX(10px) scale(1.2)',
+      '@media': {
+        'screen and (min-width: 768px)': {
+          background: 'radial-gradient(circle, green, yellow)'
+        }
+      }
+    });
+  });
+});

package/dist/utils/utils.spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.spec.d.ts","sourceRoot":"","sources":["../../lib/utils/utils.spec.js"],"names":[],"mappings":""}
+{"version":3,"file":"utils.spec.d.ts","sourceRoot":"","sources":["../../lib/utils/utils.spec.ts"],"names":[],"mappings":""}