hola-server 1.0.10 → 2.0.1

package/test/core/array.js

@@ -0,0 +1,226 @@
+const { strictEqual, deepStrictEqual } = require('assert');
+const { shuffle, remove_element, pop_n, shift_n, sum, avg, combine, sort_desc, sort_asc, sort_by_key_seq, unique, map_array_to_obj } = require('../../core/array');
+
+describe('array', function () {
+    describe('shuffle', function () {
+        it('should shuffle array in place', function () {
+            const arr = [1, 2, 3, 4, 5];
+            const original = [...arr];
+            shuffle(arr);
+            strictEqual(arr.length, original.length);
+            // All elements should still be present
+            original.forEach(el => strictEqual(arr.includes(el), true));
+        });
+
+        it('should not modify single element array', function () {
+            const arr = [1];
+            shuffle(arr);
+            deepStrictEqual(arr, [1]);
+        });
+
+        it('should handle empty array', function () {
+            const arr = [];
+            shuffle(arr);
+            deepStrictEqual(arr, []);
+        });
+    });
+
+    describe('remove_element', function () {
+        it('should remove elements by field value', function () {
+            const arr = [{ id: 1 }, { id: 2 }, { id: 1 }, { id: 3 }];
+            remove_element(arr, 'id', 1);
+            strictEqual(arr.length, 2);
+            strictEqual(arr[0].id, 2);
+            strictEqual(arr[1].id, 3);
+        });
+
+        it('should handle empty array', function () {
+            const arr = [];
+            remove_element(arr, 'id', 1);
+            strictEqual(arr.length, 0);
+        });
+
+        it('should handle no matching elements', function () {
+            const arr = [{ id: 1 }, { id: 2 }];
+            remove_element(arr, 'id', 999);
+            strictEqual(arr.length, 2);
+        });
+    });
+
+    describe('pop_n', function () {
+        it('should pop n elements from end', function () {
+            const arr = [1, 2, 3, 4, 5];
+            const result = pop_n(arr, 2);
+            deepStrictEqual(result, [5, 4]);
+            strictEqual(arr.length, 3);
+        });
+
+        it('should return undefined for empty array', function () {
+            const arr = [];
+            const result = pop_n(arr, 2);
+            strictEqual(result, undefined);
+        });
+
+        it('should return partial results when n > array length', function () {
+            const arr = [1, 2, 3];
+            const result = pop_n(arr, 5);
+            deepStrictEqual(result, [3, 2, 1]);
+            strictEqual(arr.length, 0);
+        });
+    });
+
+    describe('shift_n', function () {
+        it('should shift n elements from start', function () {
+            const arr = [1, 2, 3, 4, 5];
+            const result = shift_n(arr, 2);
+            deepStrictEqual(result, [1, 2]);
+            strictEqual(arr.length, 3);
+        });
+
+        it('should return undefined for empty array', function () {
+            const arr = [];
+            const result = shift_n(arr, 2);
+            strictEqual(result, undefined);
+        });
+
+        it('should return partial results when n > array length', function () {
+            const arr = [1, 2, 3];
+            const result = shift_n(arr, 5);
+            deepStrictEqual(result, [1, 2, 3]);
+            strictEqual(arr.length, 0);
+        });
+    });
+
+    describe('sum', function () {
+        it('should calculate sum of numbers', function () {
+            strictEqual(sum([1, 2, 3, 4, 5]), 15);
+            strictEqual(sum([1.1, 2.2, 3.3]), 6.6);
+        });
+
+        it('should return 0 for empty array', function () {
+            strictEqual(sum([]), 0);
+        });
+
+        it('should handle negative numbers', function () {
+            strictEqual(sum([10, -5, 3]), 8);
+        });
+    });
+
+    describe('avg', function () {
+        it('should calculate average of numbers', function () {
+            strictEqual(avg([1, 2, 3, 4, 5]), 3);
+            strictEqual(avg([10, 20]), 15);
+        });
+
+        it('should return 0 for empty array', function () {
+            strictEqual(avg([]), 0);
+        });
+
+        it('should handle negative numbers', function () {
+            strictEqual(avg([10, -10, 5]), 1.67);
+        });
+    });
+
+    describe('combine', function () {
+        it('should create cartesian product', function () {
+            const arr1 = [{ a: 1 }, { a: 2 }];
+            const arr2 = [{ b: 3 }, { b: 4 }];
+            const result = combine(arr1, arr2);
+            strictEqual(result.length, 4);
+            deepStrictEqual(result[0], { a: 1, b: 3 });
+            deepStrictEqual(result[1], { a: 1, b: 4 });
+            deepStrictEqual(result[2], { a: 2, b: 3 });
+            deepStrictEqual(result[3], { a: 2, b: 4 });
+        });
+
+        it('should handle empty first array', function () {
+            const result = combine([], [{ b: 1 }]);
+            deepStrictEqual(result, []);
+        });
+
+        it('should handle empty second array', function () {
+            const result = combine([{ a: 1 }], []);
+            deepStrictEqual(result, []);
+        });
+    });
+
+    describe('sort_desc', function () {
+        it('should sort array descending by attribute', function () {
+            const arr = [{ val: 3 }, { val: 1 }, { val: 2 }];
+            sort_desc(arr, 'val');
+            strictEqual(arr[0].val, 3);
+            strictEqual(arr[1].val, 2);
+            strictEqual(arr[2].val, 1);
+        });
+    });
+
+    describe('sort_asc', function () {
+        it('should sort array ascending by attribute', function () {
+            const arr = [{ val: 3 }, { val: 1 }, { val: 2 }];
+            sort_asc(arr, 'val');
+            strictEqual(arr[0].val, 1);
+            strictEqual(arr[1].val, 2);
+            strictEqual(arr[2].val, 3);
+        });
+    });
+
+    describe('sort_by_key_seq', function () {
+        it('should sort by predefined key sequence', function () {
+            const arr = [{ type: 'c' }, { type: 'a' }, { type: 'b' }];
+            const keys = ['a', 'b', 'c'];
+            sort_by_key_seq(arr, 'type', keys);
+            strictEqual(arr[0].type, 'a');
+            strictEqual(arr[1].type, 'b');
+            strictEqual(arr[2].type, 'c');
+        });
+
+        it('should handle elements not in key sequence', function () {
+            const arr = [{ type: 'x' }, { type: 'a' }, { type: 'b' }];
+            const keys = ['a', 'b', 'c'];
+            sort_by_key_seq(arr, 'type', keys);
+            // 'x' not in keys, indexOf returns -1, sorts to beginning
+            strictEqual(arr[0].type, 'x');
+        });
+    });
+
+    describe('unique', function () {
+        it('should remove duplicate primitives', function () {
+            const result = unique([1, 2, 2, 3, 1]);
+            deepStrictEqual(result, [1, 2, 3]);
+        });
+
+        it('should remove duplicate objects', function () {
+            const result = unique([{ a: 1 }, { a: 2 }, { a: 1 }]);
+            strictEqual(result.length, 2);
+        });
+
+        it('should handle empty array', function () {
+            const result = unique([]);
+            deepStrictEqual(result, []);
+        });
+
+        it('should handle array with all duplicates', function () {
+            const result = unique([1, 1, 1]);
+            deepStrictEqual(result, [1]);
+        });
+    });
+
+    describe('map_array_to_obj', function () {
+        it('should convert array to key-value object', function () {
+            const arr = [{ key: 'a', val: 1 }, { key: 'b', val: 2 }];
+            const result = map_array_to_obj(arr, 'key', 'val');
+            deepStrictEqual(result, { a: 1, b: 2 });
+        });
+
+        it('should handle duplicate keys (last wins)', function () {
+            const arr = [{ id: 'a', val: 1 }, { id: 'a', val: 2 }];
+            const result = map_array_to_obj(arr, 'id', 'val');
+            deepStrictEqual(result, { a: 2 });
+        });
+
+        it('should handle empty array', function () {
+            const result = map_array_to_obj([], 'key', 'val');
+            deepStrictEqual(result, {});
+        });
+    });
+});

package/test/core/chart.js

@@ -0,0 +1,51 @@
+const { strictEqual, deepStrictEqual } = require('assert');
+const { set_chart_header, merge_chart_data } = require('../../core/chart');
+
+describe('chart', function () {
+    describe('set_chart_header', function () {
+        it('should add prefix to headers except first', function () {
+            const arr = [['Date', 'Value1', 'Value2'], [1, 2, 3]];
+            set_chart_header(arr, 'Prefix_');
+            strictEqual(arr[0][0], 'Date');
+            strictEqual(arr[0][1], 'Prefix_Value1');
+            strictEqual(arr[0][2], 'Prefix_Value2');
+        });
+
+        it('should handle empty array', function () {
+            const arr = [];
+            set_chart_header(arr, 'Prefix_');
+            strictEqual(arr.length, 0);
+        });
+
+        it('should handle single column', function () {
+            const arr = [['Date']];
+            set_chart_header(arr, 'Prefix_');
+            strictEqual(arr[0][0], 'Date');
+        });
+    });
+
+    describe('merge_chart_data', function () {
+        it('should merge two chart data arrays', function () {
+            const arr1 = [['Date', 'A'], ['2024', 1]];
+            const arr2 = [['Date', 'B'], ['2024', 2]];
+            merge_chart_data(arr1, arr2);
+            deepStrictEqual(arr1[0], ['Date', 'A', 'B']);
+            deepStrictEqual(arr1[1], ['2024', 1, 2]);
+        });
+
+        it('should handle arrays of different lengths', function () {
+            const arr1 = [['Date', 'A'], ['2024', 1], ['2025', 2]];
+            const arr2 = [['Date', 'B'], ['2024', 3]];
+            merge_chart_data(arr1, arr2);
+            strictEqual(arr1.length, 3);
+            strictEqual(arr1[0].length, 3);
+        });
+
+        it('should handle empty arrays', function () {
+            const arr1 = [];
+            const arr2 = [['Date', 'B']];
+            merge_chart_data(arr1, arr2);
+            strictEqual(arr1.length, 0);
+        });
+    });
+});

package/test/core/file.js

@@ -0,0 +1,59 @@
+const { strictEqual } = require('assert');
+const path = require('path');
+const fs = require('fs');
+const { file_extension, file_prefix, is_file_exist, get_file_size } = require('../../core/file');
+
+describe('file', function () {
+    describe('file_extension', function () {
+        it('should extract file extension', function () {
+            strictEqual(file_extension('document.pdf'), 'pdf');
+            strictEqual(file_extension('image.png'), 'png');
+            strictEqual(file_extension('archive.tar.gz'), 'gz');
+        });
+
+        it('should return empty string for files without extension', function () {
+            strictEqual(file_extension('Makefile'), 'Makefile');
+        });
+
+        it('should handle null/undefined', function () {
+            strictEqual(file_extension(null), '');
+            strictEqual(file_extension(undefined), '');
+        });
+    });
+
+    describe('file_prefix', function () {
+        it('should extract file name prefix', function () {
+            strictEqual(file_prefix('document.pdf'), 'document');
+            strictEqual(file_prefix('image.png'), 'image');
+        });
+
+        it('should handle files without extension', function () {
+            strictEqual(file_prefix('Makefile'), 'Makefile');
+        });
+
+        it('should handle null/undefined', function () {
+            strictEqual(file_prefix(null), '');
+            strictEqual(file_prefix(undefined), '');
+        });
+    });
+
+    describe('is_file_exist', function () {
+        it('should return true for existing file', function () {
+            const testFile = path.join(__dirname, '../../package.json');
+            strictEqual(is_file_exist(testFile), true);
+        });
+
+        it('should return false for non-existing file', function () {
+            strictEqual(is_file_exist('/nonexistent/path/file.txt'), false);
+        });
+    });
+
+    describe('get_file_size', function () {
+        it('should return file size in bytes', async function () {
+            const testFile = path.join(__dirname, '../../package.json');
+            const size = await get_file_size(testFile);
+            strictEqual(typeof size, 'number');
+            strictEqual(size > 0, true);
+        });
+    });
+});

package/test/core/lhs.js

@@ -0,0 +1,44 @@
+const { strictEqual } = require('assert');
+const { get_context, verify_template, execute_template } = require('../../core/lhs');
+
+describe('lhs', function () {
+    describe('get_context', function () {
+        it('should return context with number utilities', function () {
+            const ctx = get_context();
+            strictEqual(typeof ctx.range, 'function');
+            strictEqual(typeof ctx.scale, 'function');
+            strictEqual(typeof ctx.space, 'function');
+        });
+    });
+
+    describe('verify_template', function () {
+        it('should return null for valid template', function () {
+            const result = verify_template('Hello ${name}!', { name: 'World' });
+            strictEqual(result, null);
+        });
+
+        it('should return error message for invalid template', function () {
+            const result = verify_template('Hello ${name!', { name: 'World' });
+            strictEqual(typeof result, 'string');
+            strictEqual(result.length > 0, true);
+        });
+    });
+
+    describe('execute_template', function () {
+        it('should execute template with variables', function () {
+            const result = execute_template('Hello ${name}!', { name: 'World' });
+            strictEqual(result, 'Hello World!');
+        });
+
+        it('should support expressions in template', function () {
+            const result = execute_template('Sum is ${a + b}', { a: 2, b: 3 });
+            strictEqual(result, 'Sum is 5');
+        });
+
+        it('should work with number utilities from context', function () {
+            const ctx = { ...get_context() };
+            const result = execute_template('Range: ${range(3).join(",")}', ctx);
+            strictEqual(result, 'Range: 0,1,2');
+        });
+    });
+});

package/test/core/number.js

@@ -1,17 +1,172 @@
-const { strictEqual } = require('assert');
-const { extract_number } = require('../../core/number');
+const { strictEqual, deepStrictEqual } = require('assert');
+const {
+    parse_num, extract_number, to_fixed2, round_to_fixed2,
+    range, scale, space, is_space, contains_space, is_integer,
+    random_number, random_sample, lhs_samples
+} = require('../../core/number');
 
 describe('number', function () {
-    describe('test number related method', function () {
+    describe('parse_num', function () {
+        it('should parse valid numbers', function () {
+            strictEqual(parse_num('123'), 123);
+            strictEqual(parse_num('3.14'), 3.14);
+            strictEqual(parse_num(-5), -5);
+        });
+
+        it('should return 0 for invalid values', function () {
+            strictEqual(parse_num('abc'), 0);
+            strictEqual(parse_num(null), 0);
+        });
+    });
+
+    describe('to_fixed2', function () {
+        it('should parse and round to 2 decimals', function () {
+            strictEqual(to_fixed2('3.14159'), 3.14);
+            strictEqual(to_fixed2('2.999'), 3);
+        });
+
+        it('should return 0 for invalid values', function () {
+            strictEqual(to_fixed2('abc'), 0);
+        });
+    });
+
+    describe('round_to_fixed2', function () {
+        it('should round to 2 decimal places', function () {
+            strictEqual(round_to_fixed2(3.14159), 3.14);
+            strictEqual(round_to_fixed2(2.996), 3);
+        });
+    });
+
+    describe('range', function () {
+        it('should generate range with single argument', function () {
+            deepStrictEqual(range(3), [0, 1, 2]);
+            deepStrictEqual(range(5), [0, 1, 2, 3, 4]);
+        });
+
+        it('should generate range with start and end', function () {
+            deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5]);
+            deepStrictEqual(range(0, 4), [0, 1, 2, 3, 4]);
+        });
+
+        it('should generate range with step', function () {
+            deepStrictEqual(range(0, 10, 2), [0, 2, 4, 6, 8, 10]);
+        });
+    });
+
+    describe('scale', function () {
+        it('should generate exponential scale', function () {
+            deepStrictEqual(scale(2, 8), [2, 4, 8]);
+            deepStrictEqual(scale(1, 8, 2), [1, 2, 4, 8]);
+        });
+
+        it('should work with different ratios', function () {
+            deepStrictEqual(scale(1, 27, 3), [1, 3, 9, 27]);
+        });
+    });
+
+    describe('space', function () {
+        it('should create space object', function () {
+            const s = space(0, 100);
+            strictEqual(s.min, 0);
+            strictEqual(s.max, 100);
+        });
+
+        it('should throw without min or max', function () {
+            let threw = false;
+            try { space(null, 100); } catch { threw = true; }
+            strictEqual(threw, true);
+        });
+    });
+
+    describe('is_space', function () {
+        it('should return true for space objects', function () {
+            strictEqual(is_space({ min: 0, max: 100 }), true);
+            strictEqual(is_space(space(0, 10)), true);
+        });
+
+        it('should return false for non-space values', function () {
+            strictEqual(is_space({ min: 0 }), false);
+            strictEqual(is_space(123), false);
+            strictEqual(is_space([0, 100]), false);
+        });
+    });
+
+    describe('is_integer', function () {
+        it('should detect integers', function () {
+            strictEqual(is_integer('123'), true);
+            strictEqual(is_integer('-45'), true);
+            strictEqual(is_integer('0'), true);
+        });
+
+        it('should return false for non-integers', function () {
+            strictEqual(is_integer('3.14'), false);
+            strictEqual(is_integer('abc'), false);
+        });
+    });
+
+    describe('contains_space', function () {
+        it('should detect space objects in object', function () {
+            strictEqual(contains_space({ a: space(0, 10), b: 5 }), true);
+            strictEqual(contains_space({ a: 1, b: 2 }), false);
+        });
+    });
+
+    describe('random_number', function () {
+        it('should generate number in range', function () {
+            for (let i = 0; i < 50; i++) {
+                const num = random_number(0, 10);
+                strictEqual(num >= 0 && num <= 10, true);
+            }
+        });
+
+        it('should return integer for integer bounds', function () {
+            for (let i = 0; i < 20; i++) {
+                const num = random_number(0, 100);
+                strictEqual(Number.isInteger(num), true);
+            }
+        });
+    });
+
+    describe('random_sample', function () {
+        it('should sample from arrays', function () {
+            const obj = { color: ['red', 'blue', 'green'] };
+            const sample = random_sample(obj);
+            strictEqual(['red', 'blue', 'green'].includes(sample.color), true);
+        });
+
+        it('should sample from spaces', function () {
+            const obj = { value: space(0, 100) };
+            const sample = random_sample(obj);
+            strictEqual(sample.value >= 0 && sample.value <= 100, true);
+        });
+
+        it('should preserve plain values', function () {
+            const obj = { fixed: 42 };
+            const sample = random_sample(obj);
+            strictEqual(sample.fixed, 42);
+        });
+    });
+
+    describe('lhs_samples', function () {
+        it('should generate Latin Hypercube Sampling ranges', function () {
+            const samples = lhs_samples(0, 100, 4);
+            strictEqual(samples.length, 4);
+            samples.forEach(s => {
+                strictEqual(typeof s.min, 'number');
+                strictEqual(typeof s.max, 'number');
+            });
+        });
+    });
+
+    describe('extract_number', function () {
         it('should extract number successfully', function () {
-            strictEqual(extract_number("123"), 123);
-            strictEqual(extract_number("123 abc"), 123);
-            strictEqual(extract_number("123 abc . efg"), 123);
-            strictEqual(extract_number(" abc 134.56 efg"), 134.56);
-            strictEqual(extract_number(" abc 134.56 efg . rg"), 134.56);
-            strictEqual(extract_number(" abc 134.56 efg 123 rg"), 0);
-            strictEqual(extract_number("123.67"), 123.67);
+            strictEqual(extract_number('123'), 123);
+            strictEqual(extract_number('123 abc'), 123);
+            strictEqual(extract_number(' abc 134.56 efg'), 134.56);
+        });
+
+        it('should return 0 for multiple numbers', function () {
+            strictEqual(extract_number(' abc 134.56 efg 123 rg'), 0);
         });
     });
-}
-);
+});

package/test/core/obj.js

@@ -0,0 +1,47 @@
+const { strictEqual, deepStrictEqual } = require('assert');
+const { copy_obj, is_object } = require('../../core/obj');
+
+describe('obj', function () {
+    describe('copy_obj', function () {
+        it('should copy specified attributes', function () {
+            const obj = { a: 1, b: 2, c: 3 };
+            const result = copy_obj(obj, ['a', 'c']);
+            deepStrictEqual(result, { a: 1, c: 3 });
+        });
+
+        it('should handle missing attributes', function () {
+            const obj = { a: 1 };
+            const result = copy_obj(obj, ['a', 'b']);
+            deepStrictEqual(result, { a: 1, b: undefined });
+        });
+
+        it('should return empty object for empty attrs', function () {
+            const obj = { a: 1, b: 2 };
+            const result = copy_obj(obj, []);
+            deepStrictEqual(result, {});
+        });
+    });
+
+    describe('is_object', function () {
+        it('should return true for plain objects', function () {
+            strictEqual(is_object({}), true);
+            strictEqual(is_object({ a: 1 }), true);
+        });
+
+        it('should return false for null', function () {
+            strictEqual(is_object(null), false);
+        });
+
+        it('should return false for arrays', function () {
+            strictEqual(is_object([]), false);
+            strictEqual(is_object([1, 2, 3]), false);
+        });
+
+        it('should return false for primitives', function () {
+            strictEqual(is_object('string'), false);
+            strictEqual(is_object(123), false);
+            strictEqual(is_object(true), false);
+            strictEqual(is_object(undefined), false);
+        });
+    });
+});

package/test/core/random.js

@@ -0,0 +1,24 @@
+const { strictEqual } = require('assert');
+const { random_code } = require('../../core/random');
+
+describe('random', function () {
+    describe('random_code', function () {
+        it('should generate number between 0 and 999999', function () {
+            for (let i = 0; i < 100; i++) {
+                const code = random_code();
+                strictEqual(code >= 0, true);
+                strictEqual(code < 1000000, true);
+                strictEqual(Number.isInteger(code), true);
+            }
+        });
+
+        it('should generate different values', function () {
+            const codes = new Set();
+            for (let i = 0; i < 100; i++) {
+                codes.add(random_code());
+            }
+            // Should have at least some variation
+            strictEqual(codes.size > 1, true);
+        });
+    });
+});

package/test/core/thread.js

@@ -0,0 +1,20 @@
+const { strictEqual } = require('assert');
+const { snooze } = require('../../core/thread');
+
+describe('thread', function () {
+    describe('snooze', function () {
+        it('should wait for specified milliseconds', async function () {
+            const start = Date.now();
+            await snooze(100);
+            const elapsed = Date.now() - start;
+            // Allow 50ms tolerance for timing variations
+            strictEqual(elapsed >= 90, true);
+            strictEqual(elapsed < 200, true);
+        });
+
+        it('should return a Promise', function () {
+            const result = snooze(10);
+            strictEqual(result instanceof Promise, true);
+        });
+    });
+});