initial commit

admin/playground/link/playcanvas/pcui-main/test/components/arrayinput.mjs

@@ -0,0 +1,24 @@
+import { describe, it } from 'node:test';
+import { strictEqual } from 'assert';
+
+import 'global-jsdom/register'
+
+import { ArrayInput } from '../../dist/module/src/components/ArrayInput/index.mjs';
+
+describe('ArrayInput', () => {
+    it('constructor: no args', () => {
+        const arrayInput = new ArrayInput();
+
+        strictEqual(arrayInput.class.length, 6);
+        strictEqual(arrayInput.class.contains('font-regular'), true);
+        strictEqual(arrayInput.class.contains('pcui-array-empty'), true);
+        strictEqual(arrayInput.class.contains('pcui-array-input'), true);
+        strictEqual(arrayInput.class.contains('pcui-container'), true);
+        strictEqual(arrayInput.class.contains('pcui-element'), true);
+        strictEqual(arrayInput.class.contains('pcui-flex'), true);
+
+        strictEqual(arrayInput.renderChanges, false);
+        strictEqual(arrayInput.value instanceof Array, true);
+        strictEqual(arrayInput.value.length, 0);
+    });
+});

admin/playground/link/playcanvas/pcui-main/test/components/booleaninput.mjs

@@ -0,0 +1,21 @@
+import { describe, it } from 'node:test';
+import { strictEqual } from 'assert';
+
+import 'global-jsdom/register'
+
+import { BooleanInput } from '../../dist/module/src/components/BooleanInput/index.mjs';
+
+describe('BooleanInput', () => {
+    it('constructor: no args', () => {
+        const booleanInput = new BooleanInput();
+
+        strictEqual(booleanInput.class.length, 4);
+        strictEqual(booleanInput.class.contains('font-regular'), true);
+        strictEqual(booleanInput.class.contains('pcui-boolean-input'), true);
+        strictEqual(booleanInput.class.contains('pcui-element'), true);
+        strictEqual(booleanInput.class.contains('pcui-not-flexible'), true);
+
+        strictEqual(booleanInput.type, undefined);
+        strictEqual(booleanInput.value, null);
+    });
+});

admin/playground/link/playcanvas/pcui-main/test/components/button.mjs

@@ -0,0 +1,34 @@
+import { describe, it } from 'node:test';
+import { strictEqual } from 'assert';
+
+import 'global-jsdom/register'
+
+import { Button } from '../../dist/module/src/components/Button/index.mjs';
+
+describe('Button', () => {
+    it('constructor: no args', () => {
+        const button = new Button();
+
+        strictEqual(button.class.length, 3);
+        strictEqual(button.class.contains('font-regular'), true);
+        strictEqual(button.class.contains('pcui-button'), true);
+        strictEqual(button.class.contains('pcui-element'), true);
+
+        strictEqual(button.text, undefined);
+        strictEqual(button.size, undefined);
+        strictEqual(button.icon, undefined);
+    });
+
+    it('click event', () => {
+        const button = new Button();
+
+        let clicked = false;
+        button.on('click', () => {
+            clicked = true;
+        });
+
+        button.dom.dispatchEvent(new MouseEvent('click'));
+
+        strictEqual(clicked, true);
+    });
+});

admin/playground/link/playcanvas/pcui-main/test/components/numericinput.mjs

@@ -0,0 +1,120 @@
+import { describe, it } from 'node:test';
+import { strictEqual } from 'assert';
+
+import 'global-jsdom/register'
+
+import { NumericInput } from '../../dist/module/src/components/NumericInput/index.mjs';
+
+describe('NumericInput', () => {
+    it('constructor: no args', () => {
+        const numericInput = new NumericInput();
+
+        strictEqual(numericInput.class.length, 4);
+        strictEqual(numericInput.class.contains('font-regular'), true);
+        strictEqual(numericInput.class.contains('pcui-element'), true);
+        strictEqual(numericInput.class.contains('pcui-input-element'), true);
+        strictEqual(numericInput.class.contains('pcui-numeric-input'), true);
+    });
+
+    it('steps value with up/down arrow keys', () => {
+        const numericInput = new NumericInput({
+            step: 0.1
+        });
+
+        document.body.appendChild(numericInput.dom);
+
+        numericInput.focus(true);
+
+        strictEqual(numericInput.value, 0);
+
+        const upEvent = new KeyboardEvent('keydown', {
+            key: 'ArrowUp'
+        });
+        numericInput.input.dispatchEvent(upEvent);
+
+        strictEqual(numericInput.value, 0.1);
+
+        const downEvent = new KeyboardEvent('keydown', {
+            key: 'ArrowDown'
+        });
+        numericInput.input.dispatchEvent(downEvent);
+
+        strictEqual(numericInput.value, 0);
+
+        document.body.removeChild(numericInput.dom);
+
+        numericInput.destroy();
+    });
+
+    describe('expressions', () => {
+        it('string number', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "123";
+            strictEqual(numericInput.value, 123);
+        });
+
+        it('basic addition', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "2 + 2";
+            strictEqual(numericInput.value, 4);
+        });
+
+        it('basic multiplication', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "3 * 4";
+            strictEqual(numericInput.value, 12);
+        });
+
+        it('basic subtraction', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "10 - 3";
+            strictEqual(numericInput.value, 7);
+        });
+
+        it('basic division', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "15 / 3";
+            strictEqual(numericInput.value, 5);
+        });
+
+        it('parentheses', () => {
+            const numericInput = new NumericInput();
+
+            numericInput.value = "(2 + 2) * 3";
+            strictEqual(numericInput.value, 12);
+            
+            numericInput.value = "10 / (4 - 2)";
+            strictEqual(numericInput.value, 5);
+        });
+
+        it('invalid inputs', () => {
+            const numericInput = new NumericInput();
+            
+            numericInput.value = "2 + abc";
+            strictEqual(numericInput.value, 0);
+            
+            numericInput.value = "2 +* 3";
+            strictEqual(numericInput.value, 0);
+            
+            numericInput.value = "function() {}";
+            strictEqual(numericInput.value, 0);
+        });
+
+        it('length limit', () => {
+            const numericInput = new NumericInput();
+            
+            // Expression with 19 chars works
+            numericInput.value = "1+1+1+1+1+1+1+1+1+1";
+            strictEqual(numericInput.value, 10);
+            
+            // Expression with 20 chars fails
+            numericInput.value = "1+1+1+1+1+1+1+1+1+10";
+            strictEqual(numericInput.value, 0);
+        });
+    });
+});

admin/playground/link/playcanvas/pcui-main/test/helpers/search.mjs

@@ -0,0 +1,95 @@
+import { describe, it } from 'node:test';
+import { strictEqual, deepStrictEqual } from 'assert';
+import { searchItems } from '../../dist/module/src/helpers/search.mjs';
+
+describe('searchItems', () => {
+    const items = [
+        { text: 'Apple', id: 'item1' },
+        { text: 'Banana', id: 'item2' },
+        { text: 'Application', id: 'item3' },
+        { text: 'Pineapple', id: 'item4' },
+        { text: 'Grape', id: 'item5' }
+    ];
+
+    describe('basic matching', () => {
+        it('should find exact matches and substring matches', () => {
+            const results = searchItems(items, 'text', 'Apple');
+            deepStrictEqual(results.map(r => r.id).sort(), ['item1', 'item4']);  // Apple and Pineapple
+        });
+
+        it('should be case insensitive', () => {
+            const results = searchItems(items, 'text', 'apple');
+            deepStrictEqual(results.map(r => r.id).sort(), ['item1', 'item4']);  // Apple and Pineapple
+        });
+
+        it('should find substring matches', () => {
+            const results = searchItems(items, 'text', 'app');
+            const ids = results.map(r => r.id);
+            strictEqual(ids.includes('item1'), true); // Apple
+            strictEqual(ids.includes('item3'), true); // Application
+            strictEqual(ids.includes('item4'), true); // Pineapple
+        });
+    });
+
+    describe('edit distance matching', () => {
+        it('should find close matches', () => {
+            const results = searchItems(items, 'text', 'aple', {
+                editsDistanceTolerance: 0.5
+            });
+            const ids = results.map(r => r.id);
+            strictEqual(ids.includes('item1'), true); // Apple
+        });
+
+        it('should respect editsDistanceTolerance', () => {
+            const strictResults = searchItems(items, 'text', 'aple', {
+                editsDistanceTolerance: 0.1
+            });
+            strictEqual(strictResults.length, 0, 'Should find no matches with strict tolerance');
+
+            const looseResults = searchItems(items, 'text', 'aple', {
+                editsDistanceTolerance: 0.8
+            });
+            strictEqual(looseResults.length > 0, true, 'Should find matches with loose tolerance');
+        });
+    });
+
+    describe('character containment', () => {
+        it('should respect containsCharsTolerance', () => {
+            const strictResults = searchItems(items, 'text', 'apl', {
+                containsCharsTolerance: 0.9
+            });
+            strictEqual(strictResults.length === 0, true, 'Should find no matches with strict tolerance');
+
+            const looseResults = searchItems(items, 'text', 'apl', {
+                containsCharsTolerance: 0.3
+            });
+            strictEqual(looseResults.length > 0, true, 'Should find matches with loose tolerance');
+        });
+    });
+
+    describe('result limiting', () => {
+        it('should limit number of results', () => {
+            const results = searchItems(items, 'text', 'app', {
+                limitResults: 2
+            });
+            strictEqual(results.length, 2);
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle empty search string', () => {
+            const results = searchItems(items, 'text', '');
+            deepStrictEqual(results, []);
+        });
+
+        it('should handle empty items array', () => {
+            const results = searchItems([], 'text', 'test');
+            deepStrictEqual(results, []);
+        });
+
+        it('should handle whitespace', () => {
+            const results = searchItems(items, 'text', '  Apple  ');
+            deepStrictEqual(results.map(r => r.id).sort(), ['item1', 'item4']);  // Apple and Pineapple
+        });
+    });
+});