@appsemble/utils 0.30.14-test.5 → 0.32.1-test.14

package/appMessages.test.js

@@ -1,409 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { extractAppMessages, findMessageIds } from './appMessages.js';
-describe('findMessageIds', () => {
-    it('should ignore null', () => {
-        const result = findMessageIds(null);
-        expect(result).toStrictEqual({});
-    });
-    it('should ignore non-object values', () => {
-        const result = findMessageIds('A string');
-        expect(result).toStrictEqual({});
-    });
-    it('should find message ids from a string.format remapper', () => {
-        const result = findMessageIds({ 'string.format': { messageId: 'foo' } });
-        expect(result).toStrictEqual({ foo: '' });
-    });
-    it('should return the message template', () => {
-        const result = findMessageIds({ 'string.format': { messageId: 'foo', template: 'bar' } });
-        expect(result).toStrictEqual({ foo: 'bar' });
-    });
-    it('should ignore non-string message ids', () => {
-        const result = findMessageIds({ 'string.format': { messageId: 12 } });
-        expect(result).toStrictEqual({});
-    });
-    it('should missing message ids', () => {
-        const result = findMessageIds({ 'string.format': {} });
-        expect(result).toStrictEqual({});
-    });
-    it('should recurse into arrays', () => {
-        const result = findMessageIds([
-            { 'string.format': { messageId: 'foo' } },
-            { 'string.format': { messageId: 'bar' } },
-        ]);
-        expect(result).toStrictEqual({ foo: '', bar: '' });
-    });
-    it('should recurse into objects', () => {
-        const result = findMessageIds({
-            foo: { 'string.format': { messageId: 'fooz' } },
-            bar: { 'string.format': { messageId: 'baz' } },
-        });
-        expect(result).toStrictEqual({ fooz: '', baz: '' });
-    });
-    it('should extract string.format remapper values', () => {
-        const result = findMessageIds({
-            'string.format': { messageId: 'foo', values: { translate: 'bar' } },
-        });
-        expect(result).toStrictEqual({ foo: '', bar: '' });
-    });
-});
-describe('extractAppMessages', () => {
-    it('should extract page prefixes', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                { name: 'First Page', blocks: [] },
-                { name: 'Second Page', blocks: [] },
-            ],
-        });
-        expect(result).toMatchObject({
-            app: { 'pages.first-page': 'First Page', 'pages.second-page': 'Second Page' },
-        });
-    });
-    it('should extract block header remappers', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        { type: 'test', version: '1.2.3', header: { 'string.format': { messageId: 'foo' } } },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({ messageIds: { foo: '' }, app: { 'pages.page': 'Page' } });
-    });
-    it('should extract remappers from block parameters', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            parameters: { foo: { 'string.format': { messageId: 'foo' } } },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({ messageIds: { foo: '' }, app: { 'pages.page': 'Page' } });
-    });
-    it('should extract action remap', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'noop',
-                                    remap: { 'string.format': { messageId: 'onClickMessageId' } },
-                                    onError: {
-                                        type: 'noop',
-                                        remap: { 'string.format': { messageId: 'onErrorMessageId' } },
-                                    },
-                                    onSuccess: {
-                                        type: 'noop',
-                                        remap: { 'string.format': { messageId: 'onSuccessMessageId' } },
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { onClickMessageId: '', onErrorMessageId: '', onSuccessMessageId: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract condition action if', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'condition',
-                                    if: { translate: 'ifCondition' },
-                                    then: { type: 'noop' },
-                                    else: { type: 'noop' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { ifCondition: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract dialog action title', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'dialog',
-                                    title: { translate: 'dialogTitle' },
-                                    blocks: [],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { dialogTitle: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract email action remappers', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'email',
-                                    attachments: { translate: 'attachments' },
-                                    bcc: { translate: 'bcc' },
-                                    body: { translate: 'body' },
-                                    cc: { translate: 'cc' },
-                                    subject: { translate: 'subject' },
-                                    to: { translate: 'to' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { attachments: '', bcc: '', body: '', cc: '', subject: '', to: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract flow.to action step', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'flow.to',
-                                    step: { translate: 'toPage' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { toPage: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract message action body', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'message',
-                                    body: { translate: 'messageBody' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { messageBody: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract request action remappers', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onRequest: {
-                                    type: 'request',
-                                    body: { translate: 'requestBody' },
-                                    query: { translate: 'requestQuery' },
-                                    url: { translate: 'requestUrl' },
-                                },
-                                onResourceCount: {
-                                    type: 'resource.count',
-                                    resource: 'test',
-                                    body: { translate: 'resourceCountBody' },
-                                    query: { translate: 'resourceCountQuery' },
-                                    url: { translate: 'resourceCountUrl' },
-                                },
-                                onResourceCreate: {
-                                    type: 'resource.create',
-                                    resource: 'test',
-                                    body: { translate: 'resourceCreateBody' },
-                                    query: { translate: 'resourceCreateQuery' },
-                                    url: { translate: 'resourceCreateUrl' },
-                                },
-                                onResourceDelete: {
-                                    type: 'resource.delete',
-                                    resource: 'test',
-                                    body: { translate: 'resourceDeleteBody' },
-                                    query: { translate: 'resourceDeleteQuery' },
-                                    url: { translate: 'resourceDeleteUrl' },
-                                },
-                                onResourceGet: {
-                                    type: 'resource.get',
-                                    resource: 'test',
-                                    body: { translate: 'resourceGetBody' },
-                                    query: { translate: 'resourceGetQuery' },
-                                    url: { translate: 'resourceGetUrl' },
-                                },
-                                onResourceQuery: {
-                                    type: 'resource.query',
-                                    resource: 'test',
-                                    body: { translate: 'resourceQueryBody' },
-                                    query: { translate: 'resourceQueryQuery' },
-                                    url: { translate: 'resourceQueryUrl' },
-                                },
-                                onResourceUpdate: {
-                                    type: 'resource.update',
-                                    resource: 'test',
-                                    body: { translate: 'resourceUpdateBody' },
-                                    query: { translate: 'resourceUpdateQuery' },
-                                    url: { translate: 'resourceUpdateUrl' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: {
-                requestBody: '',
-                requestQuery: '',
-                requestUrl: '',
-                resourceCountBody: '',
-                resourceCountQuery: '',
-                resourceCountUrl: '',
-                resourceCreateBody: '',
-                resourceCreateQuery: '',
-                resourceCreateUrl: '',
-                resourceDeleteBody: '',
-                resourceDeleteQuery: '',
-                resourceDeleteUrl: '',
-                resourceGetBody: '',
-                resourceGetQuery: '',
-                resourceGetUrl: '',
-                resourceQueryBody: '',
-                resourceQueryQuery: '',
-                resourceQueryUrl: '',
-                resourceUpdateBody: '',
-                resourceUpdateQuery: '',
-                resourceUpdateUrl: '',
-            },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract share action remappers', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Page',
-                    blocks: [
-                        {
-                            type: 'test',
-                            version: '1.2.3',
-                            actions: {
-                                onClick: {
-                                    type: 'share',
-                                    text: { translate: 'shareText' },
-                                    title: { translate: 'shareTitle' },
-                                    url: { translate: 'shareUrl' },
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-        });
-        expect(result).toMatchObject({
-            messageIds: { shareText: '', shareTitle: '', shareUrl: '' },
-            app: { 'pages.page': 'Page' },
-        });
-    });
-    it('should extract names from tabs pages', () => {
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [
-                {
-                    name: 'Tabs',
-                    type: 'tabs',
-                    tabs: [{ name: 'Tab', blocks: [] }],
-                },
-            ],
-        });
-        expect(result).toMatchObject({ app: { 'pages.tabs': 'Tabs', 'pages.tabs.tabs.0': 'Tab' } });
-    });
-    it('should append any messages returned by onBlock', () => {
-        const onBlock = vi.fn().mockReturnValue({ foo: 'bar' });
-        const result = extractAppMessages({
-            defaultPage: '',
-            pages: [{ name: 'Page', blocks: [{ type: '', version: '' }] }],
-        }, onBlock);
-        expect(onBlock).toHaveBeenCalledWith({ type: '', version: '' }, ['pages', 'page', 'blocks', 0]);
-        expect(result).toMatchObject({ app: { 'pages.page': 'Page' } });
-    });
-});
-//# sourceMappingURL=appMessages.test.js.map

package/blockUtils.test.d.ts

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

package/blockUtils.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getAppBlocks, normalizeBlockName, parseBlockName, prefixBlockURL, stripBlockName, } from './blockUtils.js';
-describe('normalizeBlockName', () => {
-    it('should prepend @appsemble if no organization is prepended', () => {
-        const blockName = 'form';
-        const result = normalizeBlockName(blockName);
-        expect(result).toBe(`@appsemble/${blockName}`);
-    });
-    it('should leave block name intact if organization is prepended', () => {
-        const blockName = '@example/test';
-        const result = normalizeBlockName(blockName);
-        expect(result).toBe(blockName);
-    });
-});
-describe('stripBlockName', () => {
-    it('should strip the @appsemble prefix from official blocks', () => {
-        const result = stripBlockName('@appsemble/table');
-        expect(result).toBe('table');
-    });
-    it('should keep other organization prefixes', () => {
-        const result = stripBlockName('@other/table');
-        expect(result).toBe('@other/table');
-    });
-    it('should support unprefixed block names', () => {
-        const result = stripBlockName('table');
-        expect(result).toBe('table');
-    });
-});
-describe('parseBlockName', () => {
-    it('should return a tuple of organization id and block id', () => {
-        const result = parseBlockName('@example/test');
-        expect(result).toStrictEqual(['example', 'test']);
-    });
-    it('should support numeric values', () => {
-        const result = parseBlockName('@123-foo/456-bar');
-        expect(result).toStrictEqual(['123-foo', '456-bar']);
-    });
-    it('should support official appsemble blocks', () => {
-        const result = parseBlockName('detail-viewer');
-        expect(result).toStrictEqual(['appsemble', 'detail-viewer']);
-    });
-    it('should return undefined for invalid values', () => {
-        const result = parseBlockName('FooBar');
-        expect(result).toBeUndefined();
-    });
-});
-describe('getAppBlocks', () => {
-    it('should find unique block types inside an app', () => {
-        const result = getAppBlocks({
-            name: '',
-            defaultPage: '',
-            pages: [
-                {
-                    name: '',
-                    blocks: [
-                        { type: 'foo', version: '0.0.0' },
-                        { type: '@appsemble/foo', version: '0.0.0' },
-                        { type: 'foo', version: '0.0.1' },
-                        { type: 'bar', version: '0.0.1' },
-                    ],
-                },
-            ],
-        });
-        expect(result).toStrictEqual([
-            { type: '@appsemble/foo', version: '0.0.0' },
-            { type: '@appsemble/foo', version: '0.0.1' },
-            { type: '@appsemble/bar', version: '0.0.1' },
-        ]);
-    });
-});
-describe('prefixBlockURL', () => {
-    it('should populate the API url with block properties', () => {
-        const result = prefixBlockURL({ type: '@appsemble/test', version: '1.0.0' }, 'test.css');
-        expect(result).toBe('/api/blocks/@appsemble/test/versions/1.0.0/test.css');
-    });
-});
-//# sourceMappingURL=blockUtils.test.js.map

package/constants/patterns.test.d.ts

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

package/constants/patterns.test.js

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { domainPattern, googleAnalyticsIDPattern, normalized, partialNormalized, } from './patterns.js';
-describe('partialNormalized', () => {
-    it.each([
-        ['Ffoo', 'foo'],
-        ['barB', 'bar'],
-        ['I am victorous', 'am'],
-    ])('should match %j as %j', (input, expected) => {
-        const match = input.match(partialNormalized);
-        expect(match).not.toBeNull();
-        expect(match).toHaveLength(2);
-        expect([...match]).toStrictEqual([expected, expected]);
-    });
-    it('should be reusable to compose a new regular expression', () => {
-        const composed = new RegExp(`^@${partialNormalized.source}/${partialNormalized.source}$`);
-        const match = '@foo/bar'.match(composed);
-        expect(match).not.toBeNull();
-        expect(match).toHaveLength(3);
-        expect([...match]).toStrictEqual(['@foo/bar', 'foo', 'bar']);
-    });
-});
-describe('normalized', () => {
-    it.each([
-        'foo',
-        'bar',
-        'a',
-        'ab',
-        'hyphenated-string',
-        'multi-hyphenated-string',
-        '1',
-        '10-second-move',
-        '13-37',
-    ])('should match %j', (string) => {
-        expect(string).toMatch(normalized);
-    });
-    it.each([
-        '-',
-        'Uppercase',
-        'uppercasE',
-        'camelCase',
-        'double--hyphen',
-        'trouble--double--hyphen',
-        'triple---hyphen',
-        'under_score',
-        'aććëņtèd',
-        '🐱',
-    ])('should not match %j', (string) => {
-        expect(string).not.toMatch(normalized);
-    });
-});
-describe('domainPattern', () => {
-    it.each([
-        'example.com',
-        'valid.com',
-        'definitely.valid.org',
-        'a.nl',
-        'very.deeply.nested.domain.name.example',
-    ])('should match %j', (string) => {
-        expect(string).toMatch(domainPattern);
-    });
-    it.each([
-        'a',
-        'a.a',
-        '.com',
-        '-.de',
-        'valid.ínválíd.com',
-        'example.COM',
-        'EXAMPLE.com',
-        'EXAMPLE.COM',
-        'This is a random string',
-    ])('should not match %j', (string) => {
-        expect(string).not.toMatch(domainPattern);
-    });
-});
-describe('googleAnalyticsIDPattern', () => {
-    it.each(['', 'UA-12345678-9', 'G-0123456789ABC', 'UA-211654446-1'])('should match %j', (string) => {
-        expect(string).toMatch(googleAnalyticsIDPattern);
-    });
-    it.each([' ', 'AU-123456789-0', 'UA-123-123', 'UA-1234-12345', 'G-012345678abc'])('should match %j', (string) => {
-        expect(string).not.toMatch(googleAnalyticsIDPattern);
-    });
-});
-//# sourceMappingURL=patterns.test.js.map

package/convertToCsv.test.d.ts

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

package/convertToCsv.test.js

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { convertToCsv } from './convertToCsv.js';
-describe('convertToCsv', () => {
-    it('should throw an error if input is null', () => {
-        const input = null;
-        expect(() => convertToCsv(input)).toThrow(new Error('No data'));
-    });
-    it('should return an error if the input has no keys', () => {
-        const input = {};
-        expect(() => convertToCsv(input)).toThrow(new Error('No headers could be found'));
-    });
-    it('should return an error if the input is a primitive', () => {
-        const input = 'foo';
-        expect(() => convertToCsv(input)).toThrow(new TypeError('Data is of an invalid type'));
-    });
-    it('should correctly combines all headers', () => {
-        const input = [
-            { foo: 123, baz: 1 },
-            { foo: 123, bar: 'bar' },
-        ];
-        const output = 'bar,baz,foo\r\n,1,123\r\nbar,,123\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should support an arrays of objects', () => {
-        const input = [{ foo: 123 }, { foo: 321 }];
-        const output = 'foo\r\n123\r\n321\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should escape strings containing commas', () => {
-        const input = [{ 'foo,bar': 'foo,bar' }];
-        const output = '"foo,bar"\r\n"foo,bar"\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should escape strings containing newlines', () => {
-        const input = { 'foo\r\nline2': 'foo\r\nbar' };
-        const output = '"foo\r\nline2"\r\n"foo\r\nbar"\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should escape quotes', () => {
-        const input = { 'foo "example" bar': 'Lots of "str"ings"' };
-        const output = '"foo ""example"" bar"\r\n"Lots of ""str""ings"""\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should convert date objects', () => {
-        const input = { foo: new Date(0) };
-        const output = 'foo\r\n1970-01-01T00:00:00.000Z\r\n';
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-    it('should return null on empty results', () => {
-        const input = [];
-        const output = null;
-        expect(convertToCsv(input)).toStrictEqual(output);
-    });
-});
-//# sourceMappingURL=convertToCsv.test.js.map

package/has.test.d.ts

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

package/has.test.js

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { has } from './has.js';
-describe('has', () => {
-    it('should return false for null targets', () => {
-        expect(has(null, 'toString')).toBe(false);
-    });
-    it('should return false for undefined targets', () => {
-        expect(has(undefined, 'toString')).toBe(false);
-    });
-    it('should return false for attributes inferred from the prototype chain', () => {
-        expect(has({}, 'toString')).toBe(false);
-    });
-    it('should return true for own properties', () => {
-        expect(has({ toString: null }, 'toString')).toBe(true);
-    });
-});
-//# sourceMappingURL=has.test.js.map

package/i18n.test.d.ts

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