@0djek/sveltix 0.0.12 → 0.0.14

package/dist/button/__tests__/Button_Common.ct.test.d.ts

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

package/dist/button/__tests__/Button_Common.ct.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, test, vi } from 'vitest';
+import { ButtonBuilder } from './builders/ButtonBuilder';
+import { Theme } from '../../theme';
+const textToRender = ['test', 'test1', '1', '1234123', 'asdas ad as dasdase'];
+test.each(textToRender)('renders %s', async (text) => {
+    const pom = await ButtonBuilder.create().withContent(text).build();
+    const button = pom.getButton();
+    await expect.element(button).toHaveTextContent(text);
+});

package/dist/button/__tests__/Button_OnClickEvent.ct.test.d.ts

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

package/dist/button/__tests__/Button_OnClickEvent.ct.test.js

@@ -0,0 +1,14 @@
+import { expect, test, vi } from 'vitest';
+import { ButtonBuilder } from './builders/ButtonBuilder';
+test('invokes on click callback when button is clicked', async () => {
+    const onClick = vi.fn();
+    const pom = await ButtonBuilder.create().withOnClick(onClick).withDisabled(false).build();
+    await pom.click();
+    expect(onClick).to.be.called;
+});
+test("doesn't invoke on click callback when button is disabled", async () => {
+    const onClick = vi.fn();
+    const pom = await ButtonBuilder.create().withOnClick(onClick).withDisabled(true).build();
+    const button = pom.getButton();
+    await expect.element(button).toBeDisabled();
+});

package/dist/button/__tests__/Button_OnDblClickEvent.ct.test.d.ts

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

package/dist/button/__tests__/Button_OnDblClickEvent.ct.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, test, vi } from 'vitest';
+import { ButtonBuilder } from './builders/ButtonBuilder';
+import { Theme } from '../../theme';
+test('invokes on dbl click callback when button is dbl clicked', async () => {
+    const onDblClick = vi.fn();
+    const pom = await ButtonBuilder.create().withOnDblClick(onDblClick).withDisabled(false).build();
+    await pom.dblClick();
+    expect(onDblClick).toHaveBeenCalledTimes(1);
+});
+test("doesn't invokes on dbl click callback when button is disabled and dbl clicked", async () => {
+    const onDblClick = vi.fn();
+    const pom = await ButtonBuilder.create().withOnDblClick(onDblClick).withDisabled(true).build();
+    const button = pom.getButton();
+    await expect.element(button).toBeDisabled();
+});

package/dist/cache/__tests__/Cache.test.d.ts

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

package/dist/cache/__tests__/Cache.test.js

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest';
+import { CacheBuilder } from './builders/CacheBuilder';
+test('returns not exists variant when key is not added', () => {
+    const cache = CacheBuilder.create().build();
+    const entry = cache.get('test');
+    expect(entry.exists).to.be.false;
+});
+test('returns correct value for key when key is added', () => {
+    const key = 'test';
+    const value = 1;
+    const cache = CacheBuilder.create().setEntry(key, value).build();
+    const result = cache.get(key);
+    expect(result).to.be.deep.equal({
+        exists: true,
+        value,
+    });
+});
+test('returns not exists variant when key is deleted after being added', () => {
+    const key = 'test';
+    const value = 1;
+    const cache = CacheBuilder.create().setEntry(key, value).build();
+    cache.delete(key);
+    const result = cache.get(key);
+    expect(result.exists).to.be.false;
+});
+test('returns not exists variant when key is deleted after not being added', () => {
+    const key = 'test';
+    const cache = CacheBuilder.create().build();
+    cache.delete(key);
+    const result = cache.get(key);
+    expect(result.exists).to.be.false;
+});

package/dist/cache/__tests__/MappedCache.test.d.ts

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

package/dist/cache/__tests__/MappedCache.test.js

@@ -0,0 +1,47 @@
+import { expect, test } from 'vitest';
+import { MappedCacheBuilder } from './builders/MappedCacheBuilder';
+test('returns not exists variant when map key is not added', () => {
+    const cache = MappedCacheBuilder.create().build();
+    const entry = cache.get('test', 'test1');
+    expect(entry.exists).to.be.false;
+});
+test('returns not exists variant when key is not added', () => {
+    const cache = MappedCacheBuilder.create().setEntry('test', 'test2', 1).build();
+    const entry = cache.get('test', 'test1');
+    expect(entry.exists).to.be.false;
+});
+test('returns exists variant with correct value for key when key is added', () => {
+    const mapKey = 'test';
+    const key = 'test';
+    const value = 1;
+    const cache = MappedCacheBuilder.create().setEntry(mapKey, key, value).build();
+    const result = cache.get(mapKey, key);
+    expect(result).to.be.deep.equal({
+        exists: true,
+        value: value,
+    });
+});
+test('returns not exists variant when map key is deleted after not being added', () => {
+    const cache = MappedCacheBuilder.create().build();
+    cache.delete('mapKey', 'key');
+    const result = cache.get('map', 'key');
+    expect(result.exists).to.be.false;
+});
+test('returns not exists variant when map key is deleted after being added', () => {
+    const mapKey = 'test';
+    const key = 'test';
+    const value = 1;
+    const cache = MappedCacheBuilder.create().setEntry(mapKey, key, value).build();
+    cache.delete(mapKey);
+    const result = cache.get(mapKey, key);
+    expect(result.exists).to.be.false;
+});
+test('returns not exists variant when key is deleted after being added', () => {
+    const mapKey = 'test';
+    const key = 'test';
+    const value = 1;
+    const cache = MappedCacheBuilder.create().setEntry(mapKey, key, value).build();
+    cache.delete(mapKey, key);
+    const result = cache.get(mapKey, key);
+    expect(result.exists).to.be.false;
+});

package/dist/deep-equal/__tests__/deepEqual.test.d.ts

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

package/dist/deep-equal/__tests__/deepEqual.test.js

@@ -0,0 +1,52 @@
+import { expect, test } from 'vitest';
+import { deepEqual } from '../deepEqual';
+test.each([
+    [undefined, undefined, true],
+    [null, undefined, true],
+    [undefined, null, true],
+    [5, 5, true],
+    [0, 0, true],
+    [-5, -5, true],
+    [-5, 5, false],
+    [-54, -5, false],
+    [0, -1, false],
+    [0, undefined, false],
+    [undefined, -1, false],
+    [0, null, false],
+    [null, 0, false],
+    [null, 12, false],
+    [12, null, false],
+    [NaN, NaN, false],
+    ['', '', true],
+    ['te', 'te', true],
+    ['tes', 'te', false],
+    ['tes', undefined, false],
+    [undefined, 'te', false],
+    ['tes', null, false],
+    [null, 'te', false],
+    [{ a: 'test' }, undefined, false],
+    [undefined, { a: 'test' }, false],
+    [{ a: 'test' }, null, false],
+    [null, { a: 'test' }, false],
+    [{ a: 'test' }, { a: 'test' }, true],
+    [{ a: 'test' }, { a: 'tests' }, false],
+    [{ a: { b: 't' } }, { a: 'test' }, false],
+    [{ a: { b: 't' } }, { a: { b: 't' } }, true],
+    [{ a: 'test' }, { a: { b: 't' } }, false],
+    [{ a: 'test' }, { b: 't' }, false],
+    [{ a: 'test' }, { b: 't', c: 'te' }, false],
+    [{}, {}, true],
+    [[0, 1], [0, 1], true],
+    [[], [], true],
+    [undefined, [0, 1], false],
+    [[0, 1], undefined, false],
+    [[0, 1], [0, '1'], false],
+    [[0, 1], ['0', '1'], false],
+    [[0, 1], [], false],
+    [[], [0], false],
+    [[0], 't', false],
+    ['t', [1, 2], false],
+])('returns $2 when first is $0 and second is $1', (first, second, expectedResult) => {
+    const result = deepEqual(first, second);
+    expect(result).to.be.equal(expectedResult);
+});

package/dist/heading/__tests__/ParagraphTests_Common.ct.test.d.ts

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

package/dist/heading/__tests__/ParagraphTests_Common.ct.test.js

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest';
+import { HeadingBuilder } from './HeadingBuilder';
+import { page } from 'vitest/browser';
+import { Theme } from '../../theme';
+test('renders message', async () => {
+    await HeadingBuilder.create().build();
+    const p = page.getByRole('heading');
+    await expect.element(p).toBeVisible();
+});
+const tags = [1, 2, 3, 4, 5, 6];
+test.each(tags)("correct heading tag when given '%d'", async (tag) => {
+    await HeadingBuilder.create().withTag(tag).build();
+    const heading = page.getByRole('heading', { level: tag });
+    await expect.element(heading).toBeVisible();
+});

package/dist/ordered-map/__tests__/OrderedMap_KeyIsAdded.test.d.ts

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

package/dist/ordered-map/__tests__/OrderedMap_KeyIsAdded.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest';
+import { OrderedMapBuilder } from './builders/OrderedMapBuilder';
+function createOrderedMapWith1Entry() {
+    const key = 'testKey';
+    const value = 'testValue';
+    const map = OrderedMapBuilder.create().entryToAdd(key, value).build();
+    return {
+        map,
+        key,
+        value,
+    };
+}
+test('entries prop has 1 entry', () => {
+    const { map } = createOrderedMapWith1Entry();
+    const entries = map.entries;
+    expect(entries).to.have.length(1);
+});
+test('entries prop has correct entry', () => {
+    const { map, value } = createOrderedMapWith1Entry();
+    const entries = map.entries;
+    expect(entries[0]).to.be.equal(value);
+});
+test('getByKey returns correct value', () => {
+    const { map, value, key } = createOrderedMapWith1Entry();
+    const entry = map.getByKey(key);
+    expect(entry).to.be.equal(value);
+});
+test('getByIndex returns correct value', () => {
+    const { map, value } = createOrderedMapWith1Entry();
+    const entry = map.getByIndex(0);
+    expect(entry).to.be.equal(value);
+});
+describe('when entry is removed', () => {
+    test('returns removed entry', () => {
+        const { map, key, value } = createOrderedMapWith1Entry();
+        const removedEntry = map.remove(key);
+        expect(removedEntry).to.be.equal(value);
+    });
+    test('getByKey returns undefined', () => {
+        const { map, key } = createOrderedMapWith1Entry();
+        map.remove(key);
+        const entry = map.getByKey(key);
+        expect(entry).to.be.undefined;
+    });
+    test('getByIndex returns undefined', () => {
+        const { map, key } = createOrderedMapWith1Entry();
+        map.remove(key);
+        const entry = map.getByIndex(0);
+        expect(entry).to.be.undefined;
+    });
+    test("entries prop doesn't have values", () => {
+        const { map, key } = createOrderedMapWith1Entry();
+        map.remove(key);
+        expect(map.entries).to.be.empty;
+    });
+});

package/dist/ordered-map/__tests__/OrderedMap_KeyIsNotAdded.test.d.ts

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

package/dist/ordered-map/__tests__/OrderedMap_KeyIsNotAdded.test.js

@@ -0,0 +1,21 @@
+import { expect, test } from 'vitest';
+import { OrderedMapBuilder } from './builders/OrderedMapBuilder';
+test('entries prop is empty array', () => {
+    const map = OrderedMapBuilder.create().build();
+    const entries = map.entries;
+    expect(entries).to.be.empty;
+});
+test('returns undefined when getting by key', () => {
+    const map = OrderedMapBuilder.create().build();
+    const entry = map.getByKey('test');
+    expect(entry).to.be.undefined;
+});
+test('returns undefined when getting by index', () => {
+    const map = OrderedMapBuilder.create().build();
+    const entry = map.getByIndex(0);
+    expect(entry).to.be.undefined;
+});
+test("doesn't throw when removing entry", () => {
+    const map = OrderedMapBuilder.create().build();
+    expect(map.remove('test')).to.not.throw;
+});

package/dist/paragraph/__tests__/ParagraphTests_Common.ct.test.d.ts

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

package/dist/paragraph/__tests__/ParagraphTests_Common.ct.test.js

@@ -0,0 +1,9 @@
+import { expect, test } from 'vitest';
+import { ParagraphBuilder } from './ParagraphBuilder';
+import { page } from 'vitest/browser';
+import { Theme } from '../../theme';
+test('renders message', async () => {
+    await ParagraphBuilder.create().build();
+    const p = page.getByRole('paragraph');
+    await expect.element(p).toBeVisible();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0djek/sveltix",
-	"version": "0.0.12",
+	"version": "0.0.14",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -18,8 +18,7 @@
 	},
 	"files": [
 		"dist",
-		"!dist/**/*.test.*",
-		"!dist/**/*.spec.*"
+		"!dist/__tests__/**/*.test.*"
 	],
 	"sideEffects": [
 		"**/*.css"