@appsemble/utils 0.30.14-test.6 → 0.32.1-test.15

package/i18n.test.js

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { detectLocale, sortLocales } from './i18n.js';
-describe('sortLocales', () => {
-    const tests = [
-        [
-            // The user prefers any form of English.
-            ['en'],
-            ['en'],
-        ],
-        [
-            // The user prefers international English, but is willing to accept any other form of English.
-            ['en-US', 'en'],
-            ['en-us', 'en'],
-        ],
-        [
-            // The user accepts English, preferably international English.
-            ['en', 'en-US'],
-            ['en-us', 'en'],
-        ],
-        [
-            // The user accepts any for of English, preferably international English, or British over
-            // alternative forms.
-            ['en', 'en-US', 'en-GB'],
-            ['en-us', 'en-gb', 'en'],
-        ],
-        [
-            // The accepts English, or Dutch.
-            ['en', 'nl'],
-            ['en', 'nl'],
-        ],
-        [
-            // The accepts English, or Dutch (Netherlands).
-            ['en', 'nl-NL'],
-            ['en', 'nl-nl'],
-        ],
-        [
-            // XXX because Britsh is a subtag of English, it should be preferred over Dutch
-            ['en', 'en-US', 'nl', 'nl-NL', 'nl-BE', 'en-GB'],
-            ['en-us', 'en', 'nl-nl', 'nl-be', 'nl', 'en-gb'],
-        ],
-        [
-            // More specific languages of the same subtag should be sorted first.
-            ['zh', 'zh-Hant', 'zh-Hant-HK'],
-            ['zh-hant-hk', 'zh-hant', 'zh'],
-        ],
-        [
-            // XXX because international English is a subtag of English, it should be preferred over
-            // Chinese.
-            ['en', 'zh', 'zh-Hant', 'zh-Hant-HK', 'en-US'],
-            ['en', 'zh-hant-hk', 'zh-hant', 'zh', 'en-us'],
-        ],
-        [
-            // Locales that share the same starting characters should be treated differently.
-            ['cu', 'custom', 'custom-locale', 'cu'],
-            ['cu', 'custom-locale', 'custom', 'cu'],
-        ],
-    ];
-    it.each(tests)('should sort %p as %p', (languages, expected) => {
-        const result = sortLocales(languages);
-        expect(result).toStrictEqual(expected);
-    });
-});
-describe('detectLocale', () => {
-    const tests = [
-        [['en'], ['en'], 'en'],
-        [['en', 'en-US'], ['en', 'en-US'], 'en-us'],
-        [['nl'], ['en', 'en-US'], undefined],
-        // XXX The following need to be handled by the sorting algorithm in `sortLocales()`,
-        [['en', 'nl', 'en-US'], ['en', 'nl', 'en-US'], 'en'],
-    ];
-    it.each(tests)('%p %p %p', (languages, choices, expected) => {
-        const result = detectLocale(languages, choices);
-        expect(result).toBe(expected);
-    });
-});
-//# sourceMappingURL=i18n.test.js.map

package/iterApp.test.d.ts

@@ -1 +0,0 @@
-export {};

package/iterApp.test.js

@@ -1,439 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { iterAction, iterApp, iterBlock, iterBlockList, iterPage } from './iterApp.js';
-describe('iterAction', () => {
-    it('should call the appropriate callbacks', () => {
-        const onAction = vi.fn();
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'dialog',
-            blocks: [{ type: 'list', version: '0.1.2' }],
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onBlockList).toHaveBeenCalledWith(action.blocks, ['blocks']);
-        expect(result).toBe(false);
-    });
-    it('should abort if the onAction callback returns true', () => {
-        const onAction = vi.fn().mockReturnValue(true);
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'dialog',
-            blocks: [{ type: 'list', version: '0.1.2' }],
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onBlockList).not.toHaveBeenCalled();
-        expect(result).toBe(true);
-    });
-    it('should call onAction for onSuccess', () => {
-        const onAction = vi.fn();
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'noop',
-            onSuccess: {
-                type: 'noop',
-            },
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledTimes(2);
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onAction).toHaveBeenCalledWith(action.onSuccess, ['onSuccess']);
-        expect(result).toBe(false);
-    });
-    it('should return true if onAction returns true for onSuccess', () => {
-        const onAction = vi.fn().mockImplementation((a, [prefix]) => prefix === 'onSuccess');
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'noop',
-            onSuccess: {
-                type: 'noop',
-            },
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledTimes(2);
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onAction).toHaveBeenCalledWith(action.onSuccess, ['onSuccess']);
-        expect(result).toBe(true);
-    });
-    it('should call onAction for onError', () => {
-        const onAction = vi.fn();
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'noop',
-            onError: {
-                type: 'noop',
-            },
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledTimes(2);
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onAction).toHaveBeenCalledWith(action.onError, ['onError']);
-        expect(result).toBe(false);
-    });
-    it('should return true if onAction returns true for onError', () => {
-        const onAction = vi.fn().mockImplementation((a, [prefix]) => prefix === 'onError');
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'noop',
-            onError: {
-                type: 'noop',
-            },
-        };
-        const result = iterAction(action, { onAction, onBlockList });
-        expect(onAction).toHaveBeenCalledTimes(2);
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onAction).toHaveBeenCalledWith(action.onError, ['onError']);
-        expect(result).toBe(true);
-    });
-    it('should call then and else for conditional actions', () => {
-        const onAction = vi.fn();
-        const action = {
-            type: 'condition',
-            if: true,
-            then: { type: 'noop' },
-            else: { type: 'noop' },
-        };
-        const result = iterAction(action, { onAction });
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onAction).toHaveBeenCalledWith(action.then, ['then']);
-        expect(onAction).toHaveBeenCalledWith(action.else, ['else']);
-        expect(result).toBe(false);
-    });
-    it('should return the return value of iterBlockList', () => {
-        const onAction = vi.fn();
-        const onBlockList = vi.fn().mockReturnValue(true);
-        const action = {
-            type: 'dialog',
-            blocks: [{ type: 'list', version: '0.1.2' }],
-        };
-        const result = iterAction(action, {
-            onAction,
-            onBlockList,
-        });
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onBlockList).toHaveBeenCalledWith(action.blocks, ['blocks']);
-        expect(result).toBe(true);
-    });
-    it('should not call iterBlockList if the action has no blocks', () => {
-        const onAction = vi.fn();
-        const onBlockList = vi.fn();
-        const action = {
-            type: 'log',
-        };
-        const result = iterAction(action, {
-            onAction,
-            onBlockList,
-        });
-        expect(onAction).toHaveBeenCalledWith(action, []);
-        expect(onBlockList).not.toHaveBeenCalled();
-        expect(result).toBe(false);
-    });
-});
-describe('iterBlock', () => {
-    it('should call the appropriate callbacks', () => {
-        const onAction = vi.fn();
-        const onBlock = vi.fn();
-        const block = {
-            type: 'list',
-            version: '1.2.3',
-            actions: {
-                onClick: {
-                    type: 'log',
-                },
-            },
-        };
-        const result = iterBlock(block, { onAction, onBlock });
-        expect(onAction).toHaveBeenCalledWith(block.actions.onClick, ['actions', 'onClick']);
-        expect(onBlock).toHaveBeenCalledWith(block, []);
-        expect(result).toBe(false);
-    });
-    it('should abort if onBlock returns true', () => {
-        const onAction = vi.fn();
-        const onBlock = vi.fn().mockReturnValue(true);
-        const block = {
-            type: 'list',
-            version: '1.2.3',
-            actions: {
-                onClick: {
-                    type: 'log',
-                },
-            },
-        };
-        const result = iterBlock(block, { onAction, onBlock });
-        expect(onAction).not.toHaveBeenCalled();
-        expect(onBlock).toHaveBeenCalledWith(block, []);
-        expect(result).toBe(true);
-    });
-    it('should return the return value of onAction', () => {
-        const onAction = vi.fn().mockReturnValue(true);
-        const onBlock = vi.fn();
-        const block = {
-            type: 'list',
-            version: '1.2.3',
-            actions: {
-                onClick: {
-                    type: 'log',
-                },
-            },
-        };
-        const result = iterBlock(block, { onAction, onBlock });
-        expect(onAction).toHaveBeenCalledWith(block.actions.onClick, ['actions', 'onClick']);
-        expect(onBlock).toHaveBeenCalledWith(block, []);
-        expect(result).toBe(true);
-    });
-});
-describe('iterBlockList', () => {
-    it('should call the appropriate callbacks', () => {
-        const onBlock = vi.fn();
-        const onBlockList = vi.fn();
-        const blocks = [
-            {
-                type: 'list',
-                version: '1.2.3',
-                actions: {
-                    onClick: {
-                        type: 'log',
-                    },
-                },
-            },
-        ];
-        const result = iterBlockList(blocks, { onBlockList, onBlock });
-        expect(onBlockList).toHaveBeenCalledWith(blocks, []);
-        expect(onBlock).toHaveBeenCalledWith(blocks[0], [0]);
-        expect(result).toBe(false);
-    });
-    it('should abort if onBlockList returns true', () => {
-        const onBlock = vi.fn();
-        const onBlockList = vi.fn().mockReturnValue(true);
-        const blocks = [
-            {
-                type: 'list',
-                version: '1.2.3',
-                actions: {
-                    onClick: {
-                        type: 'log',
-                    },
-                },
-            },
-        ];
-        const result = iterBlockList(blocks, { onBlockList, onBlock });
-        expect(onBlockList).toHaveBeenCalledWith(blocks, []);
-        expect(onBlock).not.toHaveBeenCalled();
-        expect(result).toBe(true);
-    });
-});
-describe('iterPage', () => {
-    it('should iterate over a page', () => {
-        const onBlockList = vi.fn();
-        const onPage = vi.fn();
-        const page = {
-            name: 'Page',
-            blocks: [],
-        };
-        const result = iterPage(page, { onBlockList, onPage });
-        expect(onBlockList).toHaveBeenCalledWith(page.blocks, ['blocks']);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(false);
-    });
-    it('should iterate over a container page', () => {
-        const onBlockList = vi.fn();
-        const onPage = vi.fn();
-        const page = {
-            name: 'Container Page',
-            type: 'container',
-            pages: [
-                {
-                    name: 'Page 1',
-                    blocks: [],
-                },
-                {
-                    name: 'Page 2',
-                    blocks: [],
-                },
-            ],
-        };
-        const result = iterPage(page, { onBlockList, onPage });
-        expect(onBlockList).toHaveBeenCalledWith(page.pages[0].blocks, [
-            'blocks',
-        ]);
-        expect(onBlockList).toHaveBeenCalledWith(page.pages[1].blocks, [
-            'blocks',
-        ]);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(false);
-    });
-    it('should abort if onPage returns true', () => {
-        const onBlockList = vi.fn();
-        const onPage = vi.fn().mockReturnValue(true);
-        const page = {
-            name: 'Page',
-            blocks: [],
-        };
-        const result = iterPage(page, { onBlockList, onPage });
-        expect(onBlockList).not.toHaveBeenCalled();
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(true);
-    });
-    it('should iterate a flow page', () => {
-        const onBlockList = vi.fn();
-        const onPage = vi.fn();
-        const page = {
-            name: 'Page',
-            type: 'flow',
-            steps: [
-                {
-                    name: 'Flow page 1',
-                    blocks: [],
-                },
-            ],
-        };
-        const result = iterPage(page, { onBlockList, onPage });
-        expect(onBlockList).toHaveBeenCalledWith(page.steps[0].blocks, ['steps', 0, 'blocks']);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(false);
-    });
-    it('should iterate a tabs page', () => {
-        const onBlockList = vi.fn();
-        const onPage = vi.fn();
-        const page = {
-            name: 'Page',
-            type: 'tabs',
-            tabs: [
-                {
-                    name: 'Tabs page 1',
-                    blocks: [],
-                },
-            ],
-        };
-        const result = iterPage(page, { onBlockList, onPage });
-        expect(onBlockList).toHaveBeenCalledWith(page.tabs[0].blocks, ['tabs', 0, 'blocks']);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(false);
-    });
-    it('should call onAction for page actions', () => {
-        const onAction = vi.fn();
-        const onPage = vi.fn();
-        const page = {
-            name: 'Page',
-            type: 'flow',
-            actions: {
-                onFlowFinish: {
-                    type: 'log',
-                },
-            },
-            steps: [],
-        };
-        const result = iterPage(page, { onAction, onPage });
-        expect(onAction).toHaveBeenCalledWith(page.actions.onFlowFinish, ['actions', 'onFlowFinish']);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(result).toBe(false);
-    });
-    it('should call onAction and onBlockList for pages with actions and sub pages', () => {
-        const onAction = vi.fn();
-        const onPage = vi.fn();
-        const onBlockList = vi.fn();
-        const page = {
-            name: 'Page',
-            type: 'flow',
-            actions: {
-                onFlowFinish: {
-                    type: 'log',
-                },
-            },
-            steps: [
-                {
-                    name: 'Test Subpage 1',
-                    blocks: [
-                        {
-                            type: 'list',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'log',
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        };
-        const result = iterPage(page, { onAction, onPage, onBlockList });
-        expect(onAction).toHaveBeenCalledWith(page.actions.onFlowFinish, ['actions', 'onFlowFinish']);
-        expect(onPage).toHaveBeenCalledWith(page, []);
-        expect(onBlockList).toHaveBeenCalledWith(page.steps[0].blocks, ['steps', 0, 'blocks']);
-        expect(result).toBe(false);
-    });
-});
-describe('iterApp', () => {
-    it('should iterate over the page of an app', () => {
-        const onPage = vi.fn();
-        const app = {
-            name: 'App',
-            defaultPage: 'Page',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [],
-                },
-            ],
-        };
-        const result = iterApp(app, { onPage });
-        expect(onPage).toHaveBeenCalledWith(app.pages[0], ['pages', 0]);
-        expect(result).toBe(false);
-    });
-    it('should abort page iteration if a callback returns true', () => {
-        const onPage = vi.fn().mockReturnValue(true);
-        const app = {
-            name: 'App',
-            defaultPage: 'Page 1',
-            pages: [
-                {
-                    name: 'Page 1',
-                    blocks: [],
-                },
-                {
-                    name: 'Page 2',
-                    blocks: [],
-                },
-            ],
-        };
-        const result = iterApp(app, { onPage });
-        expect(onPage).toHaveBeenCalledTimes(1);
-        expect(onPage).toHaveBeenCalledWith(app.pages[0], ['pages', 0]);
-        expect(result).toBe(true);
-    });
-    it('should iterate over cron jobs', () => {
-        const onAction = vi.fn();
-        const app = {
-            name: 'App',
-            defaultPage: 'Page 1',
-            pages: [],
-            cron: {
-                foo: { schedule: '', action: { type: 'noop' } },
-                bar: { schedule: '', action: { type: 'noop' } },
-            },
-        };
-        const result = iterApp(app, { onAction });
-        expect(onAction).toHaveBeenCalledTimes(2);
-        expect(onAction).toHaveBeenCalledWith(app.cron.foo.action, ['cron', 'foo', 'action']);
-        expect(onAction).toHaveBeenCalledWith(app.cron.bar.action, ['cron', 'bar', 'action']);
-        expect(result).toBe(false);
-    });
-    it('should abort cron iteration if a callback returns true', () => {
-        const onAction = vi.fn().mockReturnValue(true);
-        const app = {
-            name: 'App',
-            defaultPage: 'Page 1',
-            pages: [],
-            cron: {
-                foo: { schedule: '', action: { type: 'noop' } },
-                bar: { schedule: '', action: { type: 'noop' } },
-            },
-        };
-        const result = iterApp(app, { onAction });
-        expect(onAction).toHaveBeenCalledTimes(1);
-        expect(onAction).toHaveBeenCalledWith(app.cron.foo.action, ['cron', 'foo', 'action']);
-        expect(result).toBe(true);
-    });
-});
-//# sourceMappingURL=iterApp.test.js.map

package/jsonschema.test.d.ts

@@ -1 +0,0 @@
-export {};