@depup/payload 3.79.1-depup.0

package/dist/utilities/validateTimezones.spec.js

@@ -0,0 +1,493 @@
+import { describe, expect, it } from 'vitest';
+import { InvalidConfiguration } from '../errors/index.js';
+import { validateTimezones } from './validateTimezones.js';
+describe('validateTimezones', ()=>{
+    describe('valid timezones', ()=>{
+        it('should accept UTC timezone', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'UTC',
+                            value: 'UTC'
+                        }
+                    ]
+                })).not.toThrow();
+        });
+        it.each([
+            'America/New_York',
+            'America/Los_Angeles',
+            'America/Chicago',
+            'Europe/London',
+            'Europe/Paris',
+            'Europe/Berlin',
+            'Asia/Tokyo',
+            'Asia/Shanghai',
+            'Asia/Singapore',
+            'Australia/Sydney',
+            'Pacific/Auckland'
+        ])('should accept valid IANA timezone: %s', (timezone)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: timezone,
+                            value: timezone
+                        }
+                    ]
+                })).not.toThrow();
+        });
+        it('should accept multiple valid timezones', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'New York',
+                            value: 'America/New_York'
+                        },
+                        {
+                            label: 'London',
+                            value: 'Europe/London'
+                        },
+                        {
+                            label: 'Tokyo',
+                            value: 'Asia/Tokyo'
+                        }
+                    ]
+                })).not.toThrow();
+        });
+        it('should accept empty array', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: []
+                })).not.toThrow();
+        });
+        it('should accept undefined timezones', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: undefined
+                })).not.toThrow();
+        });
+    });
+    describe('invalid timezones', ()=>{
+        it('should throw for completely invalid timezone', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'Invalid',
+                            value: 'Invalid/Timezone'
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it('should throw for made up timezone', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'Fake',
+                            value: 'Fake/Place'
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it('should throw for empty string timezone value', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'Empty',
+                            value: ''
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it('should throw for random string timezone', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'Random',
+                            value: 'not-a-timezone'
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+    });
+    describe('misspelled timezones', ()=>{
+        it.each([
+            [
+                'Asian/Tokyo',
+                'Asia/Tokyo'
+            ],
+            [
+                'Asian/Shanghai',
+                'Asia/Shanghai'
+            ],
+            [
+                'Asian/Singapore',
+                'Asia/Singapore'
+            ],
+            [
+                'Asian/Seoul',
+                'Asia/Seoul'
+            ],
+            [
+                'Asian/Bangkok',
+                'Asia/Bangkok'
+            ]
+        ])('should throw for misspelled "Asian/" instead of "Asia/": %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it.each([
+            [
+                'Americas/New_York',
+                'America/New_York'
+            ],
+            [
+                'Americas/Los_Angeles',
+                'America/Los_Angeles'
+            ],
+            [
+                'Americas/Chicago',
+                'America/Chicago'
+            ]
+        ])('should throw for misspelled "Americas/" instead of "America/": %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it.each([
+            [
+                'Europ/London',
+                'Europe/London'
+            ],
+            [
+                'Euorpe/Paris',
+                'Europe/Paris'
+            ],
+            [
+                'Europa/Berlin',
+                'Europe/Berlin'
+            ]
+        ])('should throw for misspelled Europe region: %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it.each([
+            [
+                'Australa/Sydney',
+                'Australia/Sydney'
+            ],
+            [
+                'Austrlia/Melbourne',
+                'Australia/Melbourne'
+            ]
+        ])('should throw for misspelled Australia region: %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it.each([
+            [
+                'Pacific/Aukland',
+                'Pacific/Auckland'
+            ],
+            [
+                'Pacfic/Auckland',
+                'Pacific/Auckland'
+            ]
+        ])('should throw for misspelled Pacific region or city: %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it.each([
+            'America/NewYork',
+            'America/New-York',
+            'America/newyork'
+        ])('should throw for incorrectly formatted city name: %s', (misspelled)=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: misspelled,
+                            value: misspelled
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        // Note: Intl API is case-insensitive, so lowercase versions like 'america/new_york' are valid
+        it('should accept lowercase timezone (Intl API is case-insensitive)', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'lowercase',
+                            value: 'america/new_york'
+                        }
+                    ]
+                })).not.toThrow();
+        });
+    });
+    describe('error messages', ()=>{
+        it('should include timezone value in error message', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'Bad',
+                            value: 'Invalid/Zone'
+                        }
+                    ]
+                })).toThrow(/Invalid\/Zone/);
+        });
+        it('should include source in error message when provided', ()=>{
+            expect(()=>validateTimezones({
+                    source: 'admin.timezones.supportedTimezones',
+                    timezones: [
+                        {
+                            label: 'Bad',
+                            value: 'Invalid/Zone'
+                        }
+                    ]
+                })).toThrow(/admin\.timezones\.supportedTimezones/);
+        });
+        it('should include field name in source for field-level errors', ()=>{
+            expect(()=>validateTimezones({
+                    source: 'field "publishedAt" timezone.supportedTimezones',
+                    timezones: [
+                        {
+                            label: 'Bad',
+                            value: 'Asian/Tokyo'
+                        }
+                    ]
+                })).toThrow(/field "publishedAt"/);
+        });
+    });
+    describe('mixed valid and invalid timezones', ()=>{
+        it('should throw when array contains at least one invalid timezone', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'New York',
+                            value: 'America/New_York'
+                        },
+                        {
+                            label: 'Invalid',
+                            value: 'Asian/Tokyo'
+                        },
+                        {
+                            label: 'London',
+                            value: 'Europe/London'
+                        }
+                    ]
+                })).toThrow(InvalidConfiguration);
+        });
+        it('should throw on first invalid timezone encountered', ()=>{
+            expect(()=>validateTimezones({
+                    timezones: [
+                        {
+                            label: 'First Invalid',
+                            value: 'Fake/First'
+                        },
+                        {
+                            label: 'Second Invalid',
+                            value: 'Fake/Second'
+                        }
+                    ]
+                })).toThrow(/Fake\/First/);
+        });
+    });
+    describe('UTC offset timezones', ()=>{
+        describe('valid UTC offsets', ()=>{
+            it.each([
+                '+00:00',
+                '-00:00',
+                '+05:30',
+                '-08:00',
+                '+12:00',
+                '-12:00',
+                '+14:00',
+                '+09:30',
+                '+05:45'
+            ])('should accept valid HH:mm format offset: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `UTC${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).not.toThrow();
+            });
+            it('should accept mixed IANA and offset timezones', ()=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: 'New York',
+                                value: 'America/New_York'
+                            },
+                            {
+                                label: 'UTC+5:30',
+                                value: '+05:30'
+                            },
+                            {
+                                label: 'UTC',
+                                value: 'UTC'
+                            },
+                            {
+                                label: 'UTC-8',
+                                value: '-08:00'
+                            }
+                        ]
+                    })).not.toThrow();
+            });
+        });
+        describe('invalid UTC offsets', ()=>{
+            it.each([
+                '+0530',
+                '-0800',
+                '+0000',
+                '+1200',
+                '+00',
+                '-08',
+                '+9',
+                '-5'
+            ])('should throw for non-HH:mm format offset: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Invalid ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '+15:00',
+                '-13:00',
+                '+25:00',
+                '-20:00'
+            ])('should throw for out of range hour offset: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Invalid ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '+05:60',
+                '-08:99',
+                '+12:75',
+                '+00:61'
+            ])('should throw for invalid minutes in offset: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Invalid ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '05:30',
+                '0800',
+                '12',
+                '530'
+            ])('should throw for offset missing sign: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Missing sign ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '++05:30',
+                '--08:00',
+                '+-05:30',
+                '-+08:00'
+            ])('should throw for malformed sign in offset: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Malformed ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '+ 05:30',
+                '- 08:00',
+                '+05 :30',
+                '+05: 30'
+            ])('should throw for offset with spaces: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Spaced ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '+5:',
+                '+:30',
+                ':',
+                '+:',
+                '-:'
+            ])('should throw for incomplete offset format: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `Incomplete ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+            it.each([
+                '+05:30:00',
+                '+05:30:30',
+                '-08:00:00'
+            ])('should throw for offset with seconds: %s', (offset)=>{
+                expect(()=>validateTimezones({
+                        timezones: [
+                            {
+                                label: `With seconds ${offset}`,
+                                value: offset
+                            }
+                        ]
+                    })).toThrow(InvalidConfiguration);
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=validateTimezones.spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/validateTimezones.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { InvalidConfiguration } from '../errors/index.js'\nimport { validateTimezones } from './validateTimezones.js'\n\ndescribe('validateTimezones', () => {\n  describe('valid timezones', () => {\n    it('should accept UTC timezone', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'UTC', value: 'UTC' }],\n        }),\n      ).not.toThrow()\n    })\n\n    it.each([\n      'America/New_York',\n      'America/Los_Angeles',\n      'America/Chicago',\n      'Europe/London',\n      'Europe/Paris',\n      'Europe/Berlin',\n      'Asia/Tokyo',\n      'Asia/Shanghai',\n      'Asia/Singapore',\n      'Australia/Sydney',\n      'Pacific/Auckland',\n    ])('should accept valid IANA timezone: %s', (timezone) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: timezone, value: timezone }],\n        }),\n      ).not.toThrow()\n    })\n\n    it('should accept multiple valid timezones', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [\n            { label: 'New York', value: 'America/New_York' },\n            { label: 'London', value: 'Europe/London' },\n            { label: 'Tokyo', value: 'Asia/Tokyo' },\n          ],\n        }),\n      ).not.toThrow()\n    })\n\n    it('should accept empty array', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [],\n        }),\n      ).not.toThrow()\n    })\n\n    it('should accept undefined timezones', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: undefined,\n        }),\n      ).not.toThrow()\n    })\n  })\n\n  describe('invalid timezones', () => {\n    it('should throw for completely invalid timezone', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'Invalid', value: 'Invalid/Timezone' }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it('should throw for made up timezone', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'Fake', value: 'Fake/Place' }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it('should throw for empty string timezone value', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'Empty', value: '' }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it('should throw for random string timezone', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'Random', value: 'not-a-timezone' }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n  })\n\n  describe('misspelled timezones', () => {\n    it.each([\n      ['Asian/Tokyo', 'Asia/Tokyo'],\n      ['Asian/Shanghai', 'Asia/Shanghai'],\n      ['Asian/Singapore', 'Asia/Singapore'],\n      ['Asian/Seoul', 'Asia/Seoul'],\n      ['Asian/Bangkok', 'Asia/Bangkok'],\n    ])('should throw for misspelled \"Asian/\" instead of \"Asia/\": %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it.each([\n      ['Americas/New_York', 'America/New_York'],\n      ['Americas/Los_Angeles', 'America/Los_Angeles'],\n      ['Americas/Chicago', 'America/Chicago'],\n    ])('should throw for misspelled \"Americas/\" instead of \"America/\": %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it.each([\n      ['Europ/London', 'Europe/London'],\n      ['Euorpe/Paris', 'Europe/Paris'],\n      ['Europa/Berlin', 'Europe/Berlin'],\n    ])('should throw for misspelled Europe region: %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it.each([\n      ['Australa/Sydney', 'Australia/Sydney'],\n      ['Austrlia/Melbourne', 'Australia/Melbourne'],\n    ])('should throw for misspelled Australia region: %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it.each([\n      ['Pacific/Aukland', 'Pacific/Auckland'],\n      ['Pacfic/Auckland', 'Pacific/Auckland'],\n    ])('should throw for misspelled Pacific region or city: %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it.each([\n      'America/NewYork', // missing underscore\n      'America/New-York', // hyphen instead of underscore\n      'America/newyork', // missing underscore and wrong case for city\n    ])('should throw for incorrectly formatted city name: %s', (misspelled) => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: misspelled, value: misspelled }],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    // Note: Intl API is case-insensitive, so lowercase versions like 'america/new_york' are valid\n    it('should accept lowercase timezone (Intl API is case-insensitive)', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'lowercase', value: 'america/new_york' }],\n        }),\n      ).not.toThrow()\n    })\n  })\n\n  describe('error messages', () => {\n    it('should include timezone value in error message', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [{ label: 'Bad', value: 'Invalid/Zone' }],\n        }),\n      ).toThrow(/Invalid\\/Zone/)\n    })\n\n    it('should include source in error message when provided', () => {\n      expect(() =>\n        validateTimezones({\n          source: 'admin.timezones.supportedTimezones',\n          timezones: [{ label: 'Bad', value: 'Invalid/Zone' }],\n        }),\n      ).toThrow(/admin\\.timezones\\.supportedTimezones/)\n    })\n\n    it('should include field name in source for field-level errors', () => {\n      expect(() =>\n        validateTimezones({\n          source: 'field \"publishedAt\" timezone.supportedTimezones',\n          timezones: [{ label: 'Bad', value: 'Asian/Tokyo' }],\n        }),\n      ).toThrow(/field \"publishedAt\"/)\n    })\n  })\n\n  describe('mixed valid and invalid timezones', () => {\n    it('should throw when array contains at least one invalid timezone', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [\n            { label: 'New York', value: 'America/New_York' },\n            { label: 'Invalid', value: 'Asian/Tokyo' }, // misspelled\n            { label: 'London', value: 'Europe/London' },\n          ],\n        }),\n      ).toThrow(InvalidConfiguration)\n    })\n\n    it('should throw on first invalid timezone encountered', () => {\n      expect(() =>\n        validateTimezones({\n          timezones: [\n            { label: 'First Invalid', value: 'Fake/First' },\n            { label: 'Second Invalid', value: 'Fake/Second' },\n          ],\n        }),\n      ).toThrow(/Fake\\/First/)\n    })\n  })\n\n  describe('UTC offset timezones', () => {\n    describe('valid UTC offsets', () => {\n      it.each([\n        '+00:00',\n        '-00:00',\n        '+05:30',\n        '-08:00',\n        '+12:00',\n        '-12:00',\n        '+14:00', // max positive offset (Line Islands)\n        '+09:30', // half-hour offset\n        '+05:45', // 45-minute offset (Nepal)\n      ])('should accept valid HH:mm format offset: %s', (offset) => {\n        expect(() =>\n          validateTimezones({\n            timezones: [{ label: `UTC${offset}`, value: offset }],\n          }),\n        ).not.toThrow()\n      })\n\n      it('should accept mixed IANA and offset timezones', () => {\n        expect(() =>\n          validateTimezones({\n            timezones: [\n              { label: 'New York', value: 'America/New_York' },\n              { label: 'UTC+5:30', value: '+05:30' },\n              { label: 'UTC', value: 'UTC' },\n              { label: 'UTC-8', value: '-08:00' },\n            ],\n          }),\n        ).not.toThrow()\n      })\n    })\n\n    describe('invalid UTC offsets', () => {\n      it.each(['+0530', '-0800', '+0000', '+1200', '+00', '-08', '+9', '-5'])(\n        'should throw for non-HH:mm format offset: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Invalid ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['+15:00', '-13:00', '+25:00', '-20:00'])(\n        'should throw for out of range hour offset: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Invalid ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['+05:60', '-08:99', '+12:75', '+00:61'])(\n        'should throw for invalid minutes in offset: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Invalid ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['05:30', '0800', '12', '530'])(\n        'should throw for offset missing sign: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Missing sign ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['++05:30', '--08:00', '+-05:30', '-+08:00'])(\n        'should throw for malformed sign in offset: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Malformed ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['+ 05:30', '- 08:00', '+05 :30', '+05: 30'])(\n        'should throw for offset with spaces: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Spaced ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['+5:', '+:30', ':', '+:', '-:'])(\n        'should throw for incomplete offset format: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `Incomplete ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n\n      it.each(['+05:30:00', '+05:30:30', '-08:00:00'])(\n        'should throw for offset with seconds: %s',\n        (offset) => {\n          expect(() =>\n            validateTimezones({\n              timezones: [{ label: `With seconds ${offset}`, value: offset }],\n            }),\n          ).toThrow(InvalidConfiguration)\n        },\n      )\n    })\n  })\n})\n"],"names":["describe","expect","it","InvalidConfiguration","validateTimezones","timezones","label","value","not","toThrow","each","timezone","undefined","misspelled","source","offset"],"mappings":"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"}

package/dist/utilities/validateWhereQuery.d.ts

@@ -0,0 +1,11 @@
+import type { Where } from '../types/index.js';
+/**
+ * Validates that a "where" query is in a format in which the "where builder" can understand.
+ * Even though basic queries are valid, we need to hoist them into the "and" / "or" format.
+ * Use this function alongside `transformWhereQuery` to perform a transformation if the query is not valid.
+ * @example
+ * Inaccurate: [text][equals]=example%20post
+ * Accurate: [or][0][and][0][text][equals]=example%20post
+ */
+export declare const validateWhereQuery: (whereQuery: Where) => whereQuery is Where;
+//# sourceMappingURL=validateWhereQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateWhereQuery.d.ts","sourceRoot":"","sources":["../../src/utilities/validateWhereQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAIxD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,eAAgB,KAAK,KAAG,UAAU,IAAI,KA0CpE,CAAA"}

package/dist/utilities/validateWhereQuery.js

@@ -0,0 +1,41 @@
+import { validOperatorSet } from '../types/constants.js';
+/**
+ * Validates that a "where" query is in a format in which the "where builder" can understand.
+ * Even though basic queries are valid, we need to hoist them into the "and" / "or" format.
+ * Use this function alongside `transformWhereQuery` to perform a transformation if the query is not valid.
+ * @example
+ * Inaccurate: [text][equals]=example%20post
+ * Accurate: [or][0][and][0][text][equals]=example%20post
+ */ export const validateWhereQuery = (whereQuery)=>{
+    if (whereQuery?.or && (whereQuery?.or?.length === 0 || whereQuery?.or?.length > 0 && whereQuery?.or?.[0]?.and && whereQuery?.or?.[0]?.and?.length > 0)) {
+        // At this point we know that the whereQuery has 'or' and 'and' fields,
+        // now let's check the structure and content of these fields.
+        const isValid = whereQuery.or.every((orQuery)=>{
+            if (orQuery.and && Array.isArray(orQuery.and)) {
+                return orQuery.and.every((andQuery)=>{
+                    if (typeof andQuery !== 'object') {
+                        return false;
+                    }
+                    const andKeys = Object.keys(andQuery);
+                    // If there are no keys, it's not a valid WhereField.
+                    if (andKeys.length === 0) {
+                        return false;
+                    }
+                    for (const key of andKeys){
+                        const operator = Object.keys(andQuery[key])[0];
+                        // Check if the key is a valid Operator.
+                        if (!operator || !validOperatorSet.has(operator)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            return false;
+        });
+        return isValid;
+    }
+    return false;
+};
+
+//# sourceMappingURL=validateWhereQuery.js.map

package/dist/utilities/validateWhereQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/validateWhereQuery.ts"],"sourcesContent":["import type { Operator, Where } from '../types/index.js'\n\nimport { validOperatorSet } from '../types/constants.js'\n\n/**\n * Validates that a \"where\" query is in a format in which the \"where builder\" can understand.\n * Even though basic queries are valid, we need to hoist them into the \"and\" / \"or\" format.\n * Use this function alongside `transformWhereQuery` to perform a transformation if the query is not valid.\n * @example\n * Inaccurate: [text][equals]=example%20post\n * Accurate: [or][0][and][0][text][equals]=example%20post\n */\nexport const validateWhereQuery = (whereQuery: Where): whereQuery is Where => {\n  if (\n    whereQuery?.or &&\n    (whereQuery?.or?.length === 0 ||\n      (whereQuery?.or?.length > 0 &&\n        whereQuery?.or?.[0]?.and &&\n        whereQuery?.or?.[0]?.and?.length > 0))\n  ) {\n    // At this point we know that the whereQuery has 'or' and 'and' fields,\n    // now let's check the structure and content of these fields.\n\n    const isValid = whereQuery.or.every((orQuery) => {\n      if (orQuery.and && Array.isArray(orQuery.and)) {\n        return orQuery.and.every((andQuery) => {\n          if (typeof andQuery !== 'object') {\n            return false\n          }\n\n          const andKeys = Object.keys(andQuery)\n\n          // If there are no keys, it's not a valid WhereField.\n          if (andKeys.length === 0) {\n            return false\n          }\n\n          for (const key of andKeys) {\n            const operator = Object.keys(andQuery[key]!)[0]\n            // Check if the key is a valid Operator.\n            if (!operator || !validOperatorSet.has(operator as Operator)) {\n              return false\n            }\n          }\n          return true\n        })\n      }\n      return false\n    })\n\n    return isValid\n  }\n\n  return false\n}\n"],"names":["validOperatorSet","validateWhereQuery","whereQuery","or","length","and","isValid","every","orQuery","Array","isArray","andQuery","andKeys","Object","keys","key","operator","has"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,wBAAuB;AAExD;;;;;;;CAOC,GACD,OAAO,MAAMC,qBAAqB,CAACC;IACjC,IACEA,YAAYC,MACXD,CAAAA,YAAYC,IAAIC,WAAW,KACzBF,YAAYC,IAAIC,SAAS,KACxBF,YAAYC,IAAI,CAAC,EAAE,EAAEE,OACrBH,YAAYC,IAAI,CAAC,EAAE,EAAEE,KAAKD,SAAS,CAAC,GACxC;QACA,uEAAuE;QACvE,6DAA6D;QAE7D,MAAME,UAAUJ,WAAWC,EAAE,CAACI,KAAK,CAAC,CAACC;YACnC,IAAIA,QAAQH,GAAG,IAAII,MAAMC,OAAO,CAACF,QAAQH,GAAG,GAAG;gBAC7C,OAAOG,QAAQH,GAAG,CAACE,KAAK,CAAC,CAACI;oBACxB,IAAI,OAAOA,aAAa,UAAU;wBAChC,OAAO;oBACT;oBAEA,MAAMC,UAAUC,OAAOC,IAAI,CAACH;oBAE5B,qDAAqD;oBACrD,IAAIC,QAAQR,MAAM,KAAK,GAAG;wBACxB,OAAO;oBACT;oBAEA,KAAK,MAAMW,OAAOH,QAAS;wBACzB,MAAMI,WAAWH,OAAOC,IAAI,CAACH,QAAQ,CAACI,IAAI,CAAE,CAAC,EAAE;wBAC/C,wCAAwC;wBACxC,IAAI,CAACC,YAAY,CAAChB,iBAAiBiB,GAAG,CAACD,WAAuB;4BAC5D,OAAO;wBACT;oBACF;oBACA,OAAO;gBACT;YACF;YACA,OAAO;QACT;QAEA,OAAOV;IACT;IAEA,OAAO;AACT,EAAC"}

package/dist/utilities/wait.d.ts

@@ -0,0 +1,2 @@
+export declare function wait(ms: number): Promise<unknown>;
+//# sourceMappingURL=wait.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../src/utilities/wait.ts"],"names":[],"mappings":"AAAA,wBAAsB,IAAI,CAAC,EAAE,EAAE,MAAM,oBAIpC"}

package/dist/utilities/wait.js

@@ -0,0 +1,7 @@
+export async function wait(ms) {
+    return new Promise((resolve)=>{
+        setTimeout(resolve, ms);
+    });
+}
+
+//# sourceMappingURL=wait.js.map

package/dist/utilities/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/wait.ts"],"sourcesContent":["export async function wait(ms: number) {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms)\n  })\n}\n"],"names":["wait","ms","Promise","resolve","setTimeout"],"mappings":"AAAA,OAAO,eAAeA,KAAKC,EAAU;IACnC,OAAO,IAAIC,QAAQ,CAACC;QAClBC,WAAWD,SAASF;IACtB;AACF"}

package/dist/utilities/wordBoundariesRegex.d.ts

@@ -0,0 +1,2 @@
+export declare const wordBoundariesRegex: (input: string) => RegExp;
+//# sourceMappingURL=wordBoundariesRegex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wordBoundariesRegex.d.ts","sourceRoot":"","sources":["../../src/utilities/wordBoundariesRegex.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,UAAW,MAAM,KAAG,MAanD,CAAA"}

package/dist/utilities/wordBoundariesRegex.js

@@ -0,0 +1,15 @@
+import { escapeRegExp } from './escapeRegExp.js';
+export const wordBoundariesRegex = (input)=>{
+    const words = input.split(' ');
+    // Regex word boundaries that work for cyrillic characters - https://stackoverflow.com/a/47062016/1717697
+    const wordBoundaryBefore = '(?:(?:[^\\p{L}\\p{N}])|^)' // Converted to a non-matching group instead of positive lookbehind for Safari
+    ;
+    const wordBoundaryAfter = '(?=[^\\p{L}\\p{N}]|$)';
+    const regex = words.reduce((pattern, word, i)=>{
+        const escapedWord = escapeRegExp(word);
+        return `${pattern}(?=.*${wordBoundaryBefore}.*${escapedWord}.*${wordBoundaryAfter})${i + 1 === words.length ? '.+' : ''}`;
+    }, '');
+    return new RegExp(regex, 'i');
+};
+
+//# sourceMappingURL=wordBoundariesRegex.js.map

package/dist/utilities/wordBoundariesRegex.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/wordBoundariesRegex.ts"],"sourcesContent":["import { escapeRegExp } from './escapeRegExp.js'\n\nexport const wordBoundariesRegex = (input: string): RegExp => {\n  const words = input.split(' ')\n\n  // Regex word boundaries that work for cyrillic characters - https://stackoverflow.com/a/47062016/1717697\n  const wordBoundaryBefore = '(?:(?:[^\\\\p{L}\\\\p{N}])|^)' // Converted to a non-matching group instead of positive lookbehind for Safari\n  const wordBoundaryAfter = '(?=[^\\\\p{L}\\\\p{N}]|$)'\n  const regex = words.reduce((pattern, word, i) => {\n    const escapedWord = escapeRegExp(word)\n    return `${pattern}(?=.*${wordBoundaryBefore}.*${escapedWord}.*${wordBoundaryAfter})${\n      i + 1 === words.length ? '.+' : ''\n    }`\n  }, '')\n  return new RegExp(regex, 'i')\n}\n"],"names":["escapeRegExp","wordBoundariesRegex","input","words","split","wordBoundaryBefore","wordBoundaryAfter","regex","reduce","pattern","word","i","escapedWord","length","RegExp"],"mappings":"AAAA,SAASA,YAAY,QAAQ,oBAAmB;AAEhD,OAAO,MAAMC,sBAAsB,CAACC;IAClC,MAAMC,QAAQD,MAAME,KAAK,CAAC;IAE1B,yGAAyG;IACzG,MAAMC,qBAAqB,4BAA4B,8EAA8E;;IACrI,MAAMC,oBAAoB;IAC1B,MAAMC,QAAQJ,MAAMK,MAAM,CAAC,CAACC,SAASC,MAAMC;QACzC,MAAMC,cAAcZ,aAAaU;QACjC,OAAO,GAAGD,QAAQ,KAAK,EAAEJ,mBAAmB,EAAE,EAAEO,YAAY,EAAE,EAAEN,kBAAkB,CAAC,EACjFK,IAAI,MAAMR,MAAMU,MAAM,GAAG,OAAO,IAChC;IACJ,GAAG;IACH,OAAO,IAAIC,OAAOP,OAAO;AAC3B,EAAC"}

package/dist/utilities/wrapInternalEndpoints.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from '../config/types.js';
+export declare const wrapInternalEndpoints: (endpoints: Endpoint[]) => Endpoint[];
+//# sourceMappingURL=wrapInternalEndpoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wrapInternalEndpoints.d.ts","sourceRoot":"","sources":["../../src/utilities/wrapInternalEndpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAKlD,eAAO,MAAM,qBAAqB,cAAe,QAAQ,EAAE,KAAG,QAAQ,EAcrE,CAAA"}