payload 3.70.0 → 3.71.0-internal-debug.cd77e5d

package/dist/utilities/isolateObjectProperty.spec.js

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { isolateObjectProperty } from './isolateObjectProperty.js';
+describe('isolateObjectProperty', ()=>{
+    describe('basic isolation behavior', ()=>{
+        it('should isolate specified property from the original object', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            proxy.a = 100;
+            expect(proxy.a).toBe(100);
+            expect(original.a).toBe(1); // Original unchanged
+        });
+        it('should share non-isolated properties with the original object', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            proxy.b = 200;
+            expect(proxy.b).toBe(200);
+            expect(original.b).toBe(200); // Original also changed
+        });
+        it('should support isolating multiple properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2,
+                c: 3
+            };
+            const proxy = isolateObjectProperty(original, [
+                'a',
+                'b'
+            ]);
+            proxy.a = 100;
+            proxy.b = 200;
+            expect(proxy.a).toBe(100);
+            expect(proxy.b).toBe(200);
+            expect(original.a).toBe(1);
+            expect(original.b).toBe(2);
+        });
+        it('should support deleting isolated properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            delete proxy.a;
+            expect('a' in proxy).toBe(false);
+            expect('a' in original).toBe(true); // Original still has it
+        });
+        it('should support "in" operator for isolated properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            expect('a' in proxy).toBe(true);
+            expect('b' in proxy).toBe(true);
+            delete proxy.a;
+            expect('a' in proxy).toBe(false);
+        });
+    });
+    describe('private field access (Node 24+ compatibility)', ()=>{
+        /**
+     * Class with private fields to test that the proxy correctly handles
+     * getters/setters that access private fields (Node 24+ compatibility).
+     */ class ObjectWithPrivateFields {
+            #privateValue;
+            constructor(value){
+                this.#privateValue = value;
+            }
+            get value() {
+                return this.#privateValue;
+            }
+            set value(newValue) {
+                this.#privateValue = newValue;
+            }
+        }
+        it('should allow reading properties via getters that access private fields when not isolated', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            expect(original.value).toBe('secret');
+        });
+        it('should allow reading properties via getters that access private fields', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            const proxy = isolateObjectProperty(original, 'nonExistentKey');
+            // This would throw "Cannot read private member" if receiver is wrong
+            expect(proxy.value).toBe('secret');
+        });
+        it('should allow writing properties via setters that access private fields', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            const proxy = isolateObjectProperty(original, 'nonExistentKey');
+            // This would throw "Cannot write private member" if receiver is wrong
+            proxy.value = 'updated';
+            expect(proxy.value).toBe('updated');
+            expect(original.value).toBe('updated');
+        });
+        it('should work with Headers-like objects (simulating Request.headers)', ()=>{
+            // Simulate a Request-like object with headers
+            class MockRequest {
+                #headers;
+                constructor(){
+                    this.#headers = new Headers({
+                        'content-type': 'application/json'
+                    });
+                }
+                get headers() {
+                    return this.#headers;
+                }
+            }
+            const request = new MockRequest();
+            const proxy = isolateObjectProperty(request, 'nonExistentKey');
+            // This simulates what happens in createLocalReq when checking req.headers
+            expect(proxy.headers).toBeInstanceOf(Headers);
+            expect(proxy.headers.get('content-type')).toBe('application/json');
+        });
+    });
+});
+
+//# sourceMappingURL=isolateObjectProperty.spec.js.map

package/dist/utilities/isolateObjectProperty.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isolateObjectProperty.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { isolateObjectProperty } from './isolateObjectProperty.js'\n\ndescribe('isolateObjectProperty', () => {\n  describe('basic isolation behavior', () => {\n    it('should isolate specified property from the original object', () => {\n      const original = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      proxy.a = 100\n\n      expect(proxy.a).toBe(100)\n      expect(original.a).toBe(1) // Original unchanged\n    })\n\n    it('should share non-isolated properties with the original object', () => {\n      const original = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      proxy.b = 200\n\n      expect(proxy.b).toBe(200)\n      expect(original.b).toBe(200) // Original also changed\n    })\n\n    it('should support isolating multiple properties', () => {\n      const original = { a: 1, b: 2, c: 3 }\n      const proxy = isolateObjectProperty(original, ['a', 'b'])\n\n      proxy.a = 100\n      proxy.b = 200\n\n      expect(proxy.a).toBe(100)\n      expect(proxy.b).toBe(200)\n      expect(original.a).toBe(1)\n      expect(original.b).toBe(2)\n    })\n\n    it('should support deleting isolated properties', () => {\n      const original: Record<string, any> = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      delete proxy.a\n\n      expect('a' in proxy).toBe(false)\n      expect('a' in original).toBe(true) // Original still has it\n    })\n\n    it('should support \"in\" operator for isolated properties', () => {\n      const original: Record<string, any> = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      expect('a' in proxy).toBe(true)\n      expect('b' in proxy).toBe(true)\n\n      delete proxy.a\n      expect('a' in proxy).toBe(false)\n    })\n  })\n\n  describe('private field access (Node 24+ compatibility)', () => {\n    /**\n     * Class with private fields to test that the proxy correctly handles\n     * getters/setters that access private fields (Node 24+ compatibility).\n     */\n    class ObjectWithPrivateFields {\n      #privateValue: string\n\n      constructor(value: string) {\n        this.#privateValue = value\n      }\n\n      get value(): string {\n        return this.#privateValue\n      }\n\n      set value(newValue: string) {\n        this.#privateValue = newValue\n      }\n    }\n\n    it('should allow reading properties via getters that access private fields when not isolated', () => {\n      const original = new ObjectWithPrivateFields('secret')\n\n      expect(original.value).toBe('secret')\n    })\n\n    it('should allow reading properties via getters that access private fields', () => {\n      const original = new ObjectWithPrivateFields('secret')\n      const proxy = isolateObjectProperty(original, 'nonExistentKey' as keyof typeof original)\n\n      // This would throw \"Cannot read private member\" if receiver is wrong\n      expect(proxy.value).toBe('secret')\n    })\n\n    it('should allow writing properties via setters that access private fields', () => {\n      const original = new ObjectWithPrivateFields('secret')\n      const proxy = isolateObjectProperty(original, 'nonExistentKey' as keyof typeof original)\n\n      // This would throw \"Cannot write private member\" if receiver is wrong\n      proxy.value = 'updated'\n\n      expect(proxy.value).toBe('updated')\n      expect(original.value).toBe('updated')\n    })\n\n    it('should work with Headers-like objects (simulating Request.headers)', () => {\n      // Simulate a Request-like object with headers\n      class MockRequest {\n        #headers: Headers\n\n        constructor() {\n          this.#headers = new Headers({ 'content-type': 'application/json' })\n        }\n\n        get headers(): Headers {\n          return this.#headers\n        }\n      }\n\n      const request = new MockRequest()\n      const proxy = isolateObjectProperty(request, 'nonExistentKey' as keyof typeof request)\n\n      // This simulates what happens in createLocalReq when checking req.headers\n      expect(proxy.headers).toBeInstanceOf(Headers)\n      expect(proxy.headers.get('content-type')).toBe('application/json')\n    })\n  })\n})\n"],"names":["describe","expect","it","isolateObjectProperty","original","a","b","proxy","toBe","c","ObjectWithPrivateFields","value","newValue","MockRequest","Headers","headers","request","toBeInstanceOf","get"],"mappings":"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"}

package/dist/utilities/optionsAreEqual.d.ts

@@ -0,0 +1,7 @@
+import type { Option } from '../fields/config/types.js';
+/**
+ * Compares two arrays of options by their values.
+ * Returns true if both arrays contain the same values (order-independent).
+ */
+export declare const optionsAreEqual: (options1: Option[] | undefined, options2: Option[] | undefined) => boolean;
+//# sourceMappingURL=optionsAreEqual.d.ts.map

package/dist/utilities/optionsAreEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionsAreEqual.d.ts","sourceRoot":"","sources":["../../src/utilities/optionsAreEqual.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAYvD;;;GAGG;AACH,eAAO,MAAM,eAAe,aAChB,MAAM,EAAE,GAAG,SAAS,YACpB,MAAM,EAAE,GAAG,SAAS,KAC7B,OA2BF,CAAA"}

package/dist/utilities/optionsAreEqual.js

@@ -0,0 +1,35 @@
+/**
+ * Extracts the value from an option-like object or string.
+ */ const getOptionValue = (option)=>{
+    if (typeof option === 'string') {
+        return option;
+    }
+    return option.value;
+};
+/**
+ * Compares two arrays of options by their values.
+ * Returns true if both arrays contain the same values (order-independent).
+ */ export const optionsAreEqual = (options1, options2)=>{
+    if (!options1 && !options2) {
+        return true;
+    }
+    if (!options1 || !options2) {
+        return false;
+    }
+    if (options1.length !== options2.length) {
+        return false;
+    }
+    const values1 = new Set(options1.map(getOptionValue));
+    const values2 = new Set(options2.map(getOptionValue));
+    if (values1.size !== values2.size) {
+        return false;
+    }
+    for (const value of values1){
+        if (!values2.has(value)) {
+            return false;
+        }
+    }
+    return true;
+};
+
+//# sourceMappingURL=optionsAreEqual.js.map

package/dist/utilities/optionsAreEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/optionsAreEqual.ts"],"sourcesContent":["import type { Option } from '../fields/config/types.js'\n\n/**\n * Extracts the value from an option-like object or string.\n */\nconst getOptionValue = (option: Option): string => {\n  if (typeof option === 'string') {\n    return option\n  }\n  return option.value\n}\n\n/**\n * Compares two arrays of options by their values.\n * Returns true if both arrays contain the same values (order-independent).\n */\nexport const optionsAreEqual = (\n  options1: Option[] | undefined,\n  options2: Option[] | undefined,\n): boolean => {\n  if (!options1 && !options2) {\n    return true\n  }\n\n  if (!options1 || !options2) {\n    return false\n  }\n\n  if (options1.length !== options2.length) {\n    return false\n  }\n\n  const values1 = new Set(options1.map(getOptionValue))\n  const values2 = new Set(options2.map(getOptionValue))\n\n  if (values1.size !== values2.size) {\n    return false\n  }\n\n  for (const value of values1) {\n    if (!values2.has(value)) {\n      return false\n    }\n  }\n\n  return true\n}\n"],"names":["getOptionValue","option","value","optionsAreEqual","options1","options2","length","values1","Set","map","values2","size","has"],"mappings":"AAEA;;CAEC,GACD,MAAMA,iBAAiB,CAACC;IACtB,IAAI,OAAOA,WAAW,UAAU;QAC9B,OAAOA;IACT;IACA,OAAOA,OAAOC,KAAK;AACrB;AAEA;;;CAGC,GACD,OAAO,MAAMC,kBAAkB,CAC7BC,UACAC;IAEA,IAAI,CAACD,YAAY,CAACC,UAAU;QAC1B,OAAO;IACT;IAEA,IAAI,CAACD,YAAY,CAACC,UAAU;QAC1B,OAAO;IACT;IAEA,IAAID,SAASE,MAAM,KAAKD,SAASC,MAAM,EAAE;QACvC,OAAO;IACT;IAEA,MAAMC,UAAU,IAAIC,IAAIJ,SAASK,GAAG,CAACT;IACrC,MAAMU,UAAU,IAAIF,IAAIH,SAASI,GAAG,CAACT;IAErC,IAAIO,QAAQI,IAAI,KAAKD,QAAQC,IAAI,EAAE;QACjC,OAAO;IACT;IAEA,KAAK,MAAMT,SAASK,QAAS;QAC3B,IAAI,CAACG,QAAQE,GAAG,CAACV,QAAQ;YACvB,OAAO;QACT;IACF;IAEA,OAAO;AACT,EAAC"}

package/dist/utilities/optionsAreEqual.spec.js

@@ -0,0 +1,319 @@
+import { describe, expect, it } from 'vitest';
+import { optionsAreEqual } from './optionsAreEqual.js';
+describe('optionsAreEqual', ()=>{
+    describe('with string options', ()=>{
+        it('should return true for identical string arrays', ()=>{
+            expect(optionsAreEqual([
+                'a',
+                'b',
+                'c'
+            ], [
+                'a',
+                'b',
+                'c'
+            ])).toBe(true);
+        });
+        it('should return true for same values in different order', ()=>{
+            expect(optionsAreEqual([
+                'a',
+                'b',
+                'c'
+            ], [
+                'c',
+                'a',
+                'b'
+            ])).toBe(true);
+        });
+        it('should return false for different values', ()=>{
+            expect(optionsAreEqual([
+                'a',
+                'b'
+            ], [
+                'a',
+                'c'
+            ])).toBe(false);
+        });
+        it('should return false for different lengths', ()=>{
+            expect(optionsAreEqual([
+                'a',
+                'b'
+            ], [
+                'a',
+                'b',
+                'c'
+            ])).toBe(false);
+        });
+    });
+    describe('with object options', ()=>{
+        it('should return true for identical object arrays', ()=>{
+            const options1 = [
+                {
+                    label: 'Option A',
+                    value: 'a'
+                },
+                {
+                    label: 'Option B',
+                    value: 'b'
+                }
+            ];
+            const options2 = [
+                {
+                    label: 'Option A',
+                    value: 'a'
+                },
+                {
+                    label: 'Option B',
+                    value: 'b'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(true);
+        });
+        it('should return true for same values with different labels', ()=>{
+            const options1 = [
+                {
+                    label: 'First Label',
+                    value: 'a'
+                },
+                {
+                    label: 'Second Label',
+                    value: 'b'
+                }
+            ];
+            const options2 = [
+                {
+                    label: 'Different Label A',
+                    value: 'a'
+                },
+                {
+                    label: 'Different Label B',
+                    value: 'b'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(true);
+        });
+        it('should return true for same values in different order', ()=>{
+            const options1 = [
+                {
+                    label: 'A',
+                    value: 'a'
+                },
+                {
+                    label: 'B',
+                    value: 'b'
+                }
+            ];
+            const options2 = [
+                {
+                    label: 'B',
+                    value: 'b'
+                },
+                {
+                    label: 'A',
+                    value: 'a'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(true);
+        });
+        it('should return false for different values', ()=>{
+            const options1 = [
+                {
+                    label: 'A',
+                    value: 'a'
+                },
+                {
+                    label: 'B',
+                    value: 'b'
+                }
+            ];
+            const options2 = [
+                {
+                    label: 'A',
+                    value: 'a'
+                },
+                {
+                    label: 'C',
+                    value: 'c'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(false);
+        });
+    });
+    describe('with mixed string and object options', ()=>{
+        it('should return true when string and object have same value', ()=>{
+            const options1 = [
+                'a',
+                'b'
+            ];
+            const options2 = [
+                {
+                    label: 'A',
+                    value: 'a'
+                },
+                {
+                    label: 'B',
+                    value: 'b'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(true);
+        });
+        it('should return false when values differ', ()=>{
+            const options1 = [
+                'a',
+                'b'
+            ];
+            const options2 = [
+                {
+                    label: 'A',
+                    value: 'a'
+                },
+                {
+                    label: 'C',
+                    value: 'c'
+                }
+            ];
+            expect(optionsAreEqual(options1, options2)).toBe(false);
+        });
+    });
+    describe('with timezone-like options', ()=>{
+        it('should return true for identical timezone options', ()=>{
+            const globalTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'Los Angeles',
+                    value: 'America/Los_Angeles'
+                },
+                {
+                    label: 'London',
+                    value: 'Europe/London'
+                }
+            ];
+            const fieldTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'Los Angeles',
+                    value: 'America/Los_Angeles'
+                },
+                {
+                    label: 'London',
+                    value: 'Europe/London'
+                }
+            ];
+            expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(true);
+        });
+        it('should return false for custom offset timezones vs IANA timezones', ()=>{
+            const globalTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'Los Angeles',
+                    value: 'America/Los_Angeles'
+                }
+            ];
+            const fieldTimezones = [
+                {
+                    label: 'UTC+5:30',
+                    value: '+05:30'
+                },
+                {
+                    label: 'UTC-8',
+                    value: '-08:00'
+                }
+            ];
+            expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false);
+        });
+        it('should return false for mixed IANA and offset vs pure IANA', ()=>{
+            const globalTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'London',
+                    value: 'Europe/London'
+                }
+            ];
+            const fieldTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'UTC+5:30',
+                    value: '+05:30'
+                }
+            ];
+            expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false);
+        });
+        it('should return false for subset of global timezones', ()=>{
+            const globalTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                },
+                {
+                    label: 'Los Angeles',
+                    value: 'America/Los_Angeles'
+                },
+                {
+                    label: 'London',
+                    value: 'Europe/London'
+                }
+            ];
+            const fieldTimezones = [
+                {
+                    label: 'New York',
+                    value: 'America/New_York'
+                }
+            ];
+            expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false);
+        });
+    });
+    describe('edge cases', ()=>{
+        it('should return true for both undefined', ()=>{
+            expect(optionsAreEqual(undefined, undefined)).toBe(true);
+        });
+        it('should return false for one undefined', ()=>{
+            expect(optionsAreEqual([
+                'a'
+            ], undefined)).toBe(false);
+            expect(optionsAreEqual(undefined, [
+                'a'
+            ])).toBe(false);
+        });
+        it('should return true for both empty arrays', ()=>{
+            expect(optionsAreEqual([], [])).toBe(true);
+        });
+        it('should return false for empty vs non-empty', ()=>{
+            expect(optionsAreEqual([], [
+                'a'
+            ])).toBe(false);
+            expect(optionsAreEqual([
+                'a'
+            ], [])).toBe(false);
+        });
+        it('should handle duplicate values in source (uses Set)', ()=>{
+            // If there are duplicates, the Set will dedupe them
+            // So ['a', 'a', 'b'] becomes Set{'a', 'b'} with size 2
+            // and ['a', 'b'] becomes Set{'a', 'b'} with size 2
+            // But the arrays have different lengths, so they're not equal
+            expect(optionsAreEqual([
+                'a',
+                'a',
+                'b'
+            ], [
+                'a',
+                'b'
+            ])).toBe(false);
+        });
+    });
+});
+
+//# sourceMappingURL=optionsAreEqual.spec.js.map

package/dist/utilities/optionsAreEqual.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/optionsAreEqual.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { optionsAreEqual } from './optionsAreEqual.js'\n\ndescribe('optionsAreEqual', () => {\n  describe('with string options', () => {\n    it('should return true for identical string arrays', () => {\n      expect(optionsAreEqual(['a', 'b', 'c'], ['a', 'b', 'c'])).toBe(true)\n    })\n\n    it('should return true for same values in different order', () => {\n      expect(optionsAreEqual(['a', 'b', 'c'], ['c', 'a', 'b'])).toBe(true)\n    })\n\n    it('should return false for different values', () => {\n      expect(optionsAreEqual(['a', 'b'], ['a', 'c'])).toBe(false)\n    })\n\n    it('should return false for different lengths', () => {\n      expect(optionsAreEqual(['a', 'b'], ['a', 'b', 'c'])).toBe(false)\n    })\n  })\n\n  describe('with object options', () => {\n    it('should return true for identical object arrays', () => {\n      const options1 = [\n        { label: 'Option A', value: 'a' },\n        { label: 'Option B', value: 'b' },\n      ]\n      const options2 = [\n        { label: 'Option A', value: 'a' },\n        { label: 'Option B', value: 'b' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(true)\n    })\n\n    it('should return true for same values with different labels', () => {\n      const options1 = [\n        { label: 'First Label', value: 'a' },\n        { label: 'Second Label', value: 'b' },\n      ]\n      const options2 = [\n        { label: 'Different Label A', value: 'a' },\n        { label: 'Different Label B', value: 'b' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(true)\n    })\n\n    it('should return true for same values in different order', () => {\n      const options1 = [\n        { label: 'A', value: 'a' },\n        { label: 'B', value: 'b' },\n      ]\n      const options2 = [\n        { label: 'B', value: 'b' },\n        { label: 'A', value: 'a' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(true)\n    })\n\n    it('should return false for different values', () => {\n      const options1 = [\n        { label: 'A', value: 'a' },\n        { label: 'B', value: 'b' },\n      ]\n      const options2 = [\n        { label: 'A', value: 'a' },\n        { label: 'C', value: 'c' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(false)\n    })\n  })\n\n  describe('with mixed string and object options', () => {\n    it('should return true when string and object have same value', () => {\n      const options1 = ['a', 'b']\n      const options2 = [\n        { label: 'A', value: 'a' },\n        { label: 'B', value: 'b' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(true)\n    })\n\n    it('should return false when values differ', () => {\n      const options1 = ['a', 'b']\n      const options2 = [\n        { label: 'A', value: 'a' },\n        { label: 'C', value: 'c' },\n      ]\n      expect(optionsAreEqual(options1, options2)).toBe(false)\n    })\n  })\n\n  describe('with timezone-like options', () => {\n    it('should return true for identical timezone options', () => {\n      const globalTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'Los Angeles', value: 'America/Los_Angeles' },\n        { label: 'London', value: 'Europe/London' },\n      ]\n      const fieldTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'Los Angeles', value: 'America/Los_Angeles' },\n        { label: 'London', value: 'Europe/London' },\n      ]\n      expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(true)\n    })\n\n    it('should return false for custom offset timezones vs IANA timezones', () => {\n      const globalTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'Los Angeles', value: 'America/Los_Angeles' },\n      ]\n      const fieldTimezones = [\n        { label: 'UTC+5:30', value: '+05:30' },\n        { label: 'UTC-8', value: '-08:00' },\n      ]\n      expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false)\n    })\n\n    it('should return false for mixed IANA and offset vs pure IANA', () => {\n      const globalTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'London', value: 'Europe/London' },\n      ]\n      const fieldTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'UTC+5:30', value: '+05:30' },\n      ]\n      expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false)\n    })\n\n    it('should return false for subset of global timezones', () => {\n      const globalTimezones = [\n        { label: 'New York', value: 'America/New_York' },\n        { label: 'Los Angeles', value: 'America/Los_Angeles' },\n        { label: 'London', value: 'Europe/London' },\n      ]\n      const fieldTimezones = [{ label: 'New York', value: 'America/New_York' }]\n      expect(optionsAreEqual(globalTimezones, fieldTimezones)).toBe(false)\n    })\n  })\n\n  describe('edge cases', () => {\n    it('should return true for both undefined', () => {\n      expect(optionsAreEqual(undefined, undefined)).toBe(true)\n    })\n\n    it('should return false for one undefined', () => {\n      expect(optionsAreEqual(['a'], undefined)).toBe(false)\n      expect(optionsAreEqual(undefined, ['a'])).toBe(false)\n    })\n\n    it('should return true for both empty arrays', () => {\n      expect(optionsAreEqual([], [])).toBe(true)\n    })\n\n    it('should return false for empty vs non-empty', () => {\n      expect(optionsAreEqual([], ['a'])).toBe(false)\n      expect(optionsAreEqual(['a'], [])).toBe(false)\n    })\n\n    it('should handle duplicate values in source (uses Set)', () => {\n      // If there are duplicates, the Set will dedupe them\n      // So ['a', 'a', 'b'] becomes Set{'a', 'b'} with size 2\n      // and ['a', 'b'] becomes Set{'a', 'b'} with size 2\n      // But the arrays have different lengths, so they're not equal\n      expect(optionsAreEqual(['a', 'a', 'b'], ['a', 'b'])).toBe(false)\n    })\n  })\n})\n"],"names":["describe","expect","it","optionsAreEqual","toBe","options1","label","value","options2","globalTimezones","fieldTimezones","undefined"],"mappings":"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"}

package/dist/utilities/validateTimezones.d.ts

@@ -0,0 +1,20 @@
+import type { Timezone } from '../config/types.js';
+type ValidateTimezonesArgs = {
+    /**
+     * The source of the timezones for error messaging
+     */
+    source?: string;
+    /**
+     * Array of timezones to validate
+     */
+    timezones: Timezone[] | undefined;
+};
+/**
+ * Validates that all provided timezones are supported by the current runtime's Intl API.
+ * Uses both Intl.DateTimeFormat and Intl.supportedValuesOf for comprehensive validation.
+ *
+ * @throws InvalidConfiguration if an unsupported timezone is found
+ */
+export declare const validateTimezones: ({ source, timezones }: ValidateTimezonesArgs) => void;
+export {};
+//# sourceMappingURL=validateTimezones.d.ts.map

package/dist/utilities/validateTimezones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTimezones.d.ts","sourceRoot":"","sources":["../../src/utilities/validateTimezones.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAIlD,KAAK,qBAAqB,GAAG;IAC3B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,SAAS,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAA;CAClC,CAAA;AAoED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,0BAA2B,qBAAqB,KAAG,IAahF,CAAA"}

package/dist/utilities/validateTimezones.js

@@ -0,0 +1,76 @@
+import { InvalidConfiguration } from '../errors/index.js';
+/**
+ * Validates a UTC offset string.
+ * Only supports the ±HH:mm format (e.g., +05:30, -08:00).
+ *
+ * Valid ranges: hours -12 to +14, minutes 0-59
+ *
+ * @returns true if the offset is valid
+ */ const isValidUtcOffset = (value)=>{
+    // Strict format check: only ±HH:mm
+    const match = value.match(/^([+-])(\d{2}):(\d{2})$/);
+    if (!match) {
+        return false;
+    }
+    const sign = match[1] === '+' ? 1 : -1;
+    const hours = parseInt(match[2], 10);
+    const minutes = parseInt(match[3], 10);
+    // Minutes must be 0-59
+    if (minutes > 59) {
+        return false;
+    }
+    // Valid range: -12:00 (-720 min) to +14:00 (+840 min)
+    const totalMinutes = sign * (hours * 60 + minutes);
+    return totalMinutes >= -720 && totalMinutes <= 840;
+};
+/**
+ * Checks if a timezone is supported by the current runtime.
+ * Supports both IANA timezone names and UTC offset formats.
+ *
+ * For IANA names: Uses Intl.DateTimeFormat and Intl.supportedValuesOf
+ * For UTC offsets: Uses native Date API to validate (±HH:mm format only)
+ */ const isTimezoneSupported = (timezoneValue)=>{
+    // UTC is always supported
+    if (timezoneValue === 'UTC') {
+        return true;
+    }
+    // Check if it's a UTC offset format (starts with + or -)
+    if (timezoneValue.startsWith('+') || timezoneValue.startsWith('-')) {
+        return isValidUtcOffset(timezoneValue);
+    }
+    // For IANA timezone names, use Intl.DateTimeFormat as primary check
+    try {
+        new Intl.DateTimeFormat('en-US', {
+            timeZone: timezoneValue
+        });
+        return true;
+    } catch  {
+    // DateTimeFormat failed, timezone is not supported
+    }
+    // Secondary check: verify against supportedValuesOf if available
+    if (typeof Intl.supportedValuesOf === 'function') {
+        const supportedTimezones = Intl.supportedValuesOf('timeZone');
+        if (supportedTimezones.includes(timezoneValue)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Validates that all provided timezones are supported by the current runtime's Intl API.
+ * Uses both Intl.DateTimeFormat and Intl.supportedValuesOf for comprehensive validation.
+ *
+ * @throws InvalidConfiguration if an unsupported timezone is found
+ */ export const validateTimezones = ({ source, timezones })=>{
+    if (!timezones?.length) {
+        return;
+    }
+    for (const timezone of timezones){
+        if (!isTimezoneSupported(timezone.value)) {
+            const sourceText = source ? ` in ${source}` : '';
+            throw new InvalidConfiguration(`Timezone ${timezone.value}${sourceText} is not supported by the current runtime via the Intl API.`);
+        }
+    }
+};
+
+//# sourceMappingURL=validateTimezones.js.map

package/dist/utilities/validateTimezones.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/validateTimezones.ts"],"sourcesContent":["import type { Timezone } from '../config/types.js'\n\nimport { InvalidConfiguration } from '../errors/index.js'\n\ntype ValidateTimezonesArgs = {\n  /**\n   * The source of the timezones for error messaging\n   */\n  source?: string\n  /**\n   * Array of timezones to validate\n   */\n  timezones: Timezone[] | undefined\n}\n\n/**\n * Validates a UTC offset string.\n * Only supports the ±HH:mm format (e.g., +05:30, -08:00).\n *\n * Valid ranges: hours -12 to +14, minutes 0-59\n *\n * @returns true if the offset is valid\n */\nconst isValidUtcOffset = (value: string): boolean => {\n  // Strict format check: only ±HH:mm\n  const match = value.match(/^([+-])(\\d{2}):(\\d{2})$/)\n  if (!match) {\n    return false\n  }\n\n  const sign = match[1] === '+' ? 1 : -1\n  const hours = parseInt(match[2]!, 10)\n  const minutes = parseInt(match[3]!, 10)\n\n  // Minutes must be 0-59\n  if (minutes > 59) {\n    return false\n  }\n\n  // Valid range: -12:00 (-720 min) to +14:00 (+840 min)\n  const totalMinutes = sign * (hours * 60 + minutes)\n  return totalMinutes >= -720 && totalMinutes <= 840\n}\n\n/**\n * Checks if a timezone is supported by the current runtime.\n * Supports both IANA timezone names and UTC offset formats.\n *\n * For IANA names: Uses Intl.DateTimeFormat and Intl.supportedValuesOf\n * For UTC offsets: Uses native Date API to validate (±HH:mm format only)\n */\nconst isTimezoneSupported = (timezoneValue: string): boolean => {\n  // UTC is always supported\n  if (timezoneValue === 'UTC') {\n    return true\n  }\n\n  // Check if it's a UTC offset format (starts with + or -)\n  if (timezoneValue.startsWith('+') || timezoneValue.startsWith('-')) {\n    return isValidUtcOffset(timezoneValue)\n  }\n\n  // For IANA timezone names, use Intl.DateTimeFormat as primary check\n  try {\n    new Intl.DateTimeFormat('en-US', { timeZone: timezoneValue })\n    return true\n  } catch {\n    // DateTimeFormat failed, timezone is not supported\n  }\n\n  // Secondary check: verify against supportedValuesOf if available\n  if (typeof Intl.supportedValuesOf === 'function') {\n    const supportedTimezones = Intl.supportedValuesOf('timeZone')\n    if (supportedTimezones.includes(timezoneValue)) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Validates that all provided timezones are supported by the current runtime's Intl API.\n * Uses both Intl.DateTimeFormat and Intl.supportedValuesOf for comprehensive validation.\n *\n * @throws InvalidConfiguration if an unsupported timezone is found\n */\nexport const validateTimezones = ({ source, timezones }: ValidateTimezonesArgs): void => {\n  if (!timezones?.length) {\n    return\n  }\n\n  for (const timezone of timezones) {\n    if (!isTimezoneSupported(timezone.value)) {\n      const sourceText = source ? ` in ${source}` : ''\n      throw new InvalidConfiguration(\n        `Timezone ${timezone.value}${sourceText} is not supported by the current runtime via the Intl API.`,\n      )\n    }\n  }\n}\n"],"names":["InvalidConfiguration","isValidUtcOffset","value","match","sign","hours","parseInt","minutes","totalMinutes","isTimezoneSupported","timezoneValue","startsWith","Intl","DateTimeFormat","timeZone","supportedValuesOf","supportedTimezones","includes","validateTimezones","source","timezones","length","timezone","sourceText"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,qBAAoB;AAazD;;;;;;;CAOC,GACD,MAAMC,mBAAmB,CAACC;IACxB,mCAAmC;IACnC,MAAMC,QAAQD,MAAMC,KAAK,CAAC;IAC1B,IAAI,CAACA,OAAO;QACV,OAAO;IACT;IAEA,MAAMC,OAAOD,KAAK,CAAC,EAAE,KAAK,MAAM,IAAI,CAAC;IACrC,MAAME,QAAQC,SAASH,KAAK,CAAC,EAAE,EAAG;IAClC,MAAMI,UAAUD,SAASH,KAAK,CAAC,EAAE,EAAG;IAEpC,uBAAuB;IACvB,IAAII,UAAU,IAAI;QAChB,OAAO;IACT;IAEA,sDAAsD;IACtD,MAAMC,eAAeJ,OAAQC,CAAAA,QAAQ,KAAKE,OAAM;IAChD,OAAOC,gBAAgB,CAAC,OAAOA,gBAAgB;AACjD;AAEA;;;;;;CAMC,GACD,MAAMC,sBAAsB,CAACC;IAC3B,0BAA0B;IAC1B,IAAIA,kBAAkB,OAAO;QAC3B,OAAO;IACT;IAEA,yDAAyD;IACzD,IAAIA,cAAcC,UAAU,CAAC,QAAQD,cAAcC,UAAU,CAAC,MAAM;QAClE,OAAOV,iBAAiBS;IAC1B;IAEA,oEAAoE;IACpE,IAAI;QACF,IAAIE,KAAKC,cAAc,CAAC,SAAS;YAAEC,UAAUJ;QAAc;QAC3D,OAAO;IACT,EAAE,OAAM;IACN,mDAAmD;IACrD;IAEA,iEAAiE;IACjE,IAAI,OAAOE,KAAKG,iBAAiB,KAAK,YAAY;QAChD,MAAMC,qBAAqBJ,KAAKG,iBAAiB,CAAC;QAClD,IAAIC,mBAAmBC,QAAQ,CAACP,gBAAgB;YAC9C,OAAO;QACT;IACF;IAEA,OAAO;AACT;AAEA;;;;;CAKC,GACD,OAAO,MAAMQ,oBAAoB,CAAC,EAAEC,MAAM,EAAEC,SAAS,EAAyB;IAC5E,IAAI,CAACA,WAAWC,QAAQ;QACtB;IACF;IAEA,KAAK,MAAMC,YAAYF,UAAW;QAChC,IAAI,CAACX,oBAAoBa,SAASpB,KAAK,GAAG;YACxC,MAAMqB,aAAaJ,SAAS,CAAC,IAAI,EAAEA,QAAQ,GAAG;YAC9C,MAAM,IAAInB,qBACR,CAAC,SAAS,EAAEsB,SAASpB,KAAK,GAAGqB,WAAW,0DAA0D,CAAC;QAEvG;IACF;AACF,EAAC"}