lightview 2.0.9 → 2.1.0

package/build-bundles.mjs

@@ -0,0 +1,109 @@
+import { build } from 'vite';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { copyFileSync, rmSync, existsSync } from 'fs';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const isWatch = process.argv.includes('--watch');
+
+const builds = [
+    { entry: 'src/lightview.js', name: 'lightview', globalName: 'Lightview' },
+    { entry: 'src/lightview-x.js', name: 'lightview-x', globalName: 'LightviewX' },
+    { entry: 'src/lightview-cdom.js', name: 'lightview-cdom', globalName: 'LightviewCDOM' },
+    { entry: 'src/lightview-all.js', name: 'lightview-all', globalName: 'LightviewAll' }
+];
+
+let building = false;
+let queued = false;
+
+async function runBuilds() {
+    if (building) {
+        queued = true;
+        return;
+    }
+    building = true;
+
+    console.log(isWatch ? 'Change detected. Rebuilding bundled files...' : 'Building bundles...');
+
+    try {
+        for (const b of builds) {
+            // console.log(`Building ${b.name}...`);
+            await build({
+                configFile: false,
+                logLevel: 'silent', // Reduce noise
+                build: {
+                    lib: {
+                        entry: resolve(__dirname, b.entry),
+                        name: b.globalName,
+                        formats: ['iife'],
+                        fileName: () => `${b.name}.js`
+                    },
+                    outDir: 'build_tmp',
+                    // Don't clean here, clean manually
+                    emptyOutDir: false,
+                    rollupOptions: {
+                        external: (id) => id.includes('/components/') || id.includes('/docs/')
+                    },
+                    minify: 'terser',
+                    terserOptions: {
+                        compress: {
+                            drop_console: false
+                        }
+                    }
+                }
+            });
+        }
+
+        // Copy files
+        for (const b of builds) {
+            try {
+                const src = resolve(__dirname, `build_tmp/${b.name}.js`);
+                const dest = resolve(__dirname, `${b.name}.js`);
+                if (existsSync(src)) {
+                    copyFileSync(src, dest);
+                    console.log(`Updated ${b.name}.js`);
+                } else {
+                    console.error(`Missing built file: ${src}`);
+                }
+            } catch (e) {
+                console.error(`Failed to copy ${b.name}.js`, e);
+            }
+        }
+
+        // Cleanup
+        if (existsSync(resolve(__dirname, 'build_tmp'))) {
+            rmSync(resolve(__dirname, 'build_tmp'), { recursive: true, force: true });
+        }
+    } catch (e) {
+        console.error('Build error:', e);
+    }
+
+    building = false;
+    if (queued) {
+        queued = false;
+        runBuilds();
+    } else {
+        if (isWatch) console.log('Waiting for changes...');
+    }
+}
+
+// Initial run
+runBuilds();
+
+if (isWatch) {
+    console.log('Watching src/ for changes...');
+    // Dynamic import to avoid errors if run in environment without fs (unlikely here but good practice)
+    const { watch } = await import('fs');
+    let debounceTimer;
+
+    // Watch src directory
+    // Note: recursive option for Linux requires Node 20+, Windows/macOS supported earlier.
+    watch(resolve(__dirname, 'src'), { recursive: true }, (event, filename) => {
+        if (filename && !filename.includes('~')) {
+            clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(() => {
+                runBuilds();
+            }, 300); // 300ms debounce
+        }
+    });
+}

package/cdom/helpers/array.js

@@ -0,0 +1,70 @@
+/**
+ * cdom ARRAY HELPERS
+ */
+
+export const count = (...args) => args.length;
+
+export const filter = (arr, predicate) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof predicate === 'function' && predicate.isLazy) {
+        return arr.filter(item => predicate.resolve(item));
+    }
+    return arr.filter(item => !!item);
+};
+
+export const map = (arr, transform) => {
+    if (!Array.isArray(arr)) return [];
+    if (typeof transform === 'string') {
+        return arr.map(item => (item && typeof item === 'object') ? item[transform] : item);
+    }
+    if (transform && transform.isLazy) {
+        return arr.map(item => transform.resolve(item));
+    }
+    return arr;
+};
+
+export const find = (arr, predicate) => {
+    if (!Array.isArray(arr)) return undefined;
+    if (predicate && predicate.isLazy) {
+        return arr.find(item => predicate.resolve(item));
+    }
+    return arr.find(item => !!item);
+};
+
+export const unique = (arr) => Array.isArray(arr) ? [...new Set(arr)] : [];
+
+export const sort = (arr, order = 'asc') => {
+    if (!Array.isArray(arr)) return [];
+    const sorted = [...arr];
+    sorted.sort((a, b) => {
+        if (a < b) return order === 'asc' ? -1 : 1;
+        if (a > b) return order === 'asc' ? 1 : -1;
+        return 0;
+    });
+    return sorted;
+};
+
+export const reverse = (arr) => Array.isArray(arr) ? [...arr].reverse() : [];
+export const first = (arr) => Array.isArray(arr) ? arr[0] : undefined;
+export const last = (arr) => Array.isArray(arr) ? arr[arr.length - 1] : undefined;
+export const slice = (arr, start, end) => Array.isArray(arr) ? arr.slice(start, end) : [];
+export const flatten = (arr) => Array.isArray(arr) ? arr.flat(Infinity) : [];
+export const join = (arr, sep = ',') => Array.isArray(arr) ? arr.join(String(sep)) : '';
+export const length = (arg) => Array.isArray(arg) ? arg.length : (arg ? String(arg).length : 0);
+
+export const registerArrayHelpers = (register) => {
+    register('count', count);
+    register('filter', filter);
+    register('map', map);
+    register('find', find);
+    register('unique', unique);
+    register('sort', sort);
+    register('reverse', reverse);
+    register('first', first);
+    register('last', last);
+    register('slice', slice);
+    register('flatten', flatten);
+    register('join', join);
+    register('len', length);
+    register('length', length);
+};

package/cdom/helpers/compare.js

@@ -0,0 +1,26 @@
+/**
+ * cdom COMPARISON HELPERS
+ */
+
+export const gt = (a, b) => a > b;
+export const lt = (a, b) => a < b;
+export const gte = (a, b) => a >= b;
+export const lte = (a, b) => a <= b;
+export const neq = (a, b) => a !== b;
+export const between = (val, min, max) => val >= min && val <= max;
+export const contains = (arr, val) => Array.isArray(arr) && arr.includes(val);
+
+export const registerCompareHelpers = (register) => {
+    register('gt', gt);
+    register('>', gt);
+    register('lt', lt);
+    register('<', lt);
+    register('gte', gte);
+    register('>=', gte);
+    register('lte', lte);
+    register('<=', lte);
+    register('neq', neq);
+    register('!=', neq);
+    register('between', between);
+    register('in', contains);
+};

package/cdom/helpers/conditional.js

@@ -0,0 +1,34 @@
+/**
+ * cdom CONDITIONAL AGGREGATE HELPERS
+ */
+
+export const sumIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    const filtered = (predicate && predicate.isLazy)
+        ? arr.filter(item => predicate.resolve(item))
+        : arr;
+    return filtered.reduce((a, b) => a + (Number(b) || 0), 0);
+};
+
+export const countIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    if (predicate && predicate.isLazy) {
+        return arr.filter(item => predicate.resolve(item)).length;
+    }
+    return arr.filter(item => !!item).length;
+};
+
+export const avgIf = (arr, predicate) => {
+    if (!Array.isArray(arr)) return 0;
+    const filtered = (predicate && predicate.isLazy)
+        ? arr.filter(item => predicate.resolve(item))
+        : arr;
+    if (filtered.length === 0) return 0;
+    return filtered.reduce((a, b) => a + (Number(b) || 0), 0) / filtered.length;
+};
+
+export const registerConditionalHelpers = (register) => {
+    register('sumIf', sumIf);
+    register('countIf', countIf);
+    register('avgIf', avgIf);
+};

package/cdom/helpers/datetime.js

@@ -0,0 +1,54 @@
+/**
+ * cdom DATE/TIME HELPERS
+ */
+
+export const now = () => new Date().getTime();
+export const today = () => {
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+};
+
+export const date = (val) => new Date(val).getTime();
+
+export const formatDate = (val, format) => {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return '';
+
+    // Minimal formatter, can be expanded
+    const options = { year: 'numeric', month: '2-digit', day: '2-digit' };
+    if (format === 'long') options.month = 'long';
+    return d.toLocaleDateString(undefined, options);
+};
+
+export const year = (val) => new Date(val).getFullYear();
+export const month = (val) => new Date(val).getMonth() + 1;
+export const day = (val) => new Date(val).getDate();
+export const weekday = (val) => new Date(val).getDay();
+
+export const addDays = (val, days) => {
+    const d = new Date(val);
+    d.setDate(d.getDate() + Number(days));
+    return d.getTime();
+};
+
+export const dateDiff = (d1, d2, unit = 'days') => {
+    const diff = Math.abs(new Date(d1) - new Date(d2));
+    if (unit === 'seconds') return diff / 1000;
+    if (unit === 'minutes') return diff / (1000 * 60);
+    if (unit === 'hours') return diff / (1000 * 60 * 60);
+    return diff / (1000 * 60 * 60 * 24);
+};
+
+export const registerDateTimeHelpers = (register) => {
+    register('now', now);
+    register('today', today);
+    register('date', date);
+    register('formatDate', formatDate);
+    register('year', year);
+    register('month', month);
+    register('day', day);
+    register('weekday', weekday);
+    register('addDays', addDays);
+    register('dateDiff', dateDiff);
+};

package/cdom/helpers/format.js

@@ -0,0 +1,20 @@
+/**
+ * cdom FORMATTING HELPERS
+ */
+
+export const number = (val, decimals = 2) => Number(val).toFixed(decimals);
+
+export const currency = (val, symbol = '$', decimals = 2) => {
+    return symbol + Number(val).toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+
+export const percent = (val, decimals = 0) => (Number(val) * 100).toFixed(decimals) + '%';
+
+export const thousands = (val) => String(val).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+
+export const registerFormatHelpers = (register) => {
+    register('number', number);
+    register('currency', currency);
+    register('percent', percent);
+    register('thousands', thousands);
+};

package/cdom/helpers/logic.js

@@ -0,0 +1,24 @@
+/**
+ * cdom LOGIC HELPERS
+ */
+
+export const ifHelper = (condition, thenVal, elseVal) => condition ? thenVal : elseVal;
+export const andHelper = (...args) => args.every(Boolean);
+export const orHelper = (...args) => args.some(Boolean);
+export const notHelper = (val) => !val;
+export const eqHelper = (a, b) => a === b;
+export const neqHelper = (a, b) => a !== b;
+
+export const registerLogicHelpers = (register) => {
+    register('if', ifHelper);
+    register('and', andHelper);
+    register('&&', andHelper);
+    register('or', orHelper);
+    register('||', orHelper);
+    register('not', notHelper);
+    register('!', notHelper);
+    register('eq', eqHelper);
+    register('==', eqHelper);
+    register('===', eqHelper);
+    register('neq', neqHelper);
+};

package/cdom/helpers/lookup.js

@@ -0,0 +1,25 @@
+/**
+ * cdom LOOKUP HELPERS
+ */
+
+export const lookup = (val, searchArr, resultArr) => {
+    if (!Array.isArray(searchArr)) return undefined;
+    const idx = searchArr.indexOf(val);
+    return idx !== -1 && Array.isArray(resultArr) ? resultArr[idx] : undefined;
+};
+
+export const vlookup = (val, table, colIdx) => {
+    if (!Array.isArray(table)) return undefined;
+    const row = table.find(r => Array.isArray(r) && r[0] === val);
+    return row ? row[colIdx - 1] : undefined;
+};
+
+export const index = (arr, idx) => Array.isArray(arr) ? arr[idx] : undefined;
+export const match = (val, arr) => Array.isArray(arr) ? arr.indexOf(val) : -1;
+
+export const registerLookupHelpers = (register) => {
+    register('lookup', lookup);
+    register('vlookup', vlookup);
+    register('index', index);
+    register('match', match);
+};

package/cdom/helpers/math.js

@@ -0,0 +1,34 @@
+/**
+ * cdom MATH HELPERS
+ */
+
+export const add = (...args) => args.reduce((a, b) => Number(a) + Number(b), 0);
+export const subtract = (a, b) => Number(a) - Number(b);
+export const multiply = (...args) => args.reduce((a, b) => Number(a) * Number(b), 1);
+export const divide = (a, b) => Number(a) / Number(b);
+
+export const round = (val, decimals = 0) => Number(Math.round(val + 'e' + decimals) + 'e-' + decimals);
+export const ceil = (val) => Math.ceil(val);
+export const floor = (val) => Math.floor(val);
+export const abs = (val) => Math.abs(val);
+export const mod = (a, b) => a % b;
+export const pow = (a, b) => Math.pow(a, b);
+export const sqrt = (val) => Math.sqrt(val);
+
+export const registerMathHelpers = (register) => {
+    register('+', add);
+    register('add', add);
+    register('-', subtract);
+    register('sub', subtract);
+    register('*', multiply);
+    register('mul', multiply);
+    register('/', divide);
+    register('div', divide);
+    register('round', round);
+    register('ceil', ceil);
+    register('floor', floor);
+    register('abs', abs);
+    register('mod', mod);
+    register('pow', pow);
+    register('sqrt', sqrt);
+};

package/cdom/helpers/network.js

@@ -0,0 +1,41 @@
+/**
+ * cdom NETWORK HELPERS
+ */
+
+/**
+ * A wrapper around the native fetch API that handles body serialization and 
+ * Content-Type headers based on the body type.
+ * 
+ * @param {string} url - The URL to fetch
+ * @param {object} options - Fetch options (method, headers, body)
+ */
+export const fetchHelper = (url, options = {}) => {
+    const fetchOptions = { ...options };
+    const headers = { ...fetchOptions.headers };
+
+    let body = fetchOptions.body;
+    if (body !== undefined) {
+        if (body !== null && typeof body === 'object') {
+            // Automatically stringify objects
+            body = JSON.stringify(body);
+            if (!headers['Content-Type']) {
+                headers['Content-Type'] = 'application/json';
+            }
+        } else {
+            // Convert everything else to string
+            body = String(body);
+            if (!headers['Content-Type']) {
+                headers['Content-Type'] = 'text/plain';
+            }
+        }
+    }
+
+    fetchOptions.body = body;
+    fetchOptions.headers = headers;
+
+    return globalThis.fetch(url, fetchOptions);
+};
+
+export const registerNetworkHelpers = (register) => {
+    register('fetch', fetchHelper);
+};

package/cdom/helpers/state.js

@@ -0,0 +1,77 @@
+/**
+ * cdom STATE/MUTATION HELPERS
+ */
+
+export const set = (target, val) => {
+    if (target && typeof target === 'object' && 'value' in target) {
+        target.value = val;
+    } else if (target && typeof target === 'function' && 'value' in target) {
+        target.value = val;
+    } else if (target && typeof target === 'object' && val && typeof val === 'object') {
+        Object.assign(target, val);
+    }
+    return val;
+};
+
+export const increment = (target, by = 1) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : 0;
+    const next = Number(current) + Number(by);
+    return set(target, next);
+};
+
+export const decrement = (target, by = 1) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : 0;
+    const next = Number(current) - Number(by);
+    return set(target, next);
+};
+
+export const toggle = (target) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : false;
+    return set(target, !current);
+};
+
+export const push = (target, item) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : [];
+    if (Array.isArray(current)) {
+        const next = [...current, item];
+        return set(target, next);
+    }
+    return current;
+};
+
+export const pop = (target) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : [];
+    if (Array.isArray(current) && current.length > 0) {
+        const next = current.slice(0, -1);
+        set(target, next);
+    }
+    return current;
+};
+
+export const assign = (target, obj) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : {};
+    const next = { ...current, ...obj };
+    return set(target, next);
+};
+
+export const clear = (target) => {
+    const current = (target && typeof target === 'object' && 'value' in target) ? target.value : null;
+    if (Array.isArray(current)) return set(target, []);
+    if (typeof current === 'object' && current !== null) return set(target, {});
+    return set(target, null);
+};
+
+export const registerStateHelpers = (register) => {
+    const opts = { pathAware: true };
+    register('set', set, opts);
+    register('increment', increment, opts);
+    register('++', increment, opts);
+    register('decrement', decrement, opts);
+    register('--', decrement, opts);
+    register('toggle', toggle, opts);
+    register('!!', toggle, opts);
+    register('push', push, opts);
+    register('pop', pop, opts);
+    register('assign', assign, opts);
+    register('clear', clear, opts);
+};

package/cdom/helpers/stats.js

@@ -0,0 +1,39 @@
+/**
+ * cdom STATISTICAL HELPERS
+ */
+
+export const sum = (...args) => args.reduce((a, b) => a + (Number(b) || 0), 0);
+export const avg = (...args) => args.length === 0 ? 0 : sum(...args) / args.length;
+export const min = (...args) => Math.min(...args);
+export const max = (...args) => Math.max(...args);
+
+export const median = (...args) => {
+    if (args.length === 0) return 0;
+    const sorted = [...args].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+
+export const stdev = (...args) => {
+    if (args.length === 0) return 0;
+    const mean = avg(...args);
+    const squareDiffs = args.map(value => Math.pow(value - mean, 2));
+    return Math.sqrt(avg(...squareDiffs));
+};
+
+export const variance = (...args) => {
+    if (args.length === 0) return 0;
+    const mean = avg(...args);
+    const squareDiffs = args.map(value => Math.pow(value - mean, 2));
+    return avg(...squareDiffs);
+};
+
+export const registerStatsHelpers = (register) => {
+    register('sum', sum);
+    register('avg', avg);
+    register('min', min);
+    register('max', max);
+    register('median', median);
+    register('stdev', stdev);
+    register('var', variance);
+};

package/cdom/helpers/string.js

@@ -0,0 +1,49 @@
+/**
+ * cdom STRING HELPERS
+ */
+
+export const join = (...args) => {
+    const separator = args[args.length - 1];
+    const items = args.slice(0, -1);
+    return items.join(separator);
+};
+
+export const concat = (...args) => args.join('');
+export const upper = (s) => String(s).toUpperCase();
+export const lower = (s) => String(s).toLowerCase();
+export const trim = (s) => String(s).trim();
+export const len = (s) => String(s).length;
+export const replace = (s, search, replacement) => String(s).replace(search, replacement);
+export const split = (s, separator) => String(s).split(separator);
+
+export const capitalize = (s) => {
+    const str = String(s);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+export const titleCase = (s) => {
+    return String(s).toLowerCase().split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+};
+
+export const contains = (s, search) => String(s).includes(search);
+export const startsWith = (s, prefix) => String(s).startsWith(prefix);
+export const endsWith = (s, suffix) => String(s).endsWith(suffix);
+
+export const defaultHelper = (val, fallback) => (val !== undefined && val !== null) ? val : fallback;
+
+export const registerStringHelpers = (register) => {
+    register('join', join);
+    register('concat', concat);
+    register('upper', upper);
+    register('lower', lower);
+    register('trim', trim);
+    register('len', len);
+    register('replace', replace);
+    register('split', split);
+    register('capitalize', capitalize);
+    register('titleCase', titleCase);
+    register('contains', contains);
+    register('startsWith', startsWith);
+    register('endsWith', endsWith);
+    register('default', defaultHelper);
+};