metaowl 0.4.1 → 0.5.0

package/build/runtime/modules/file-router.js

@@ -0,0 +1,205 @@
+/**
+ * @module FileRouter
+ *
+ * File-based routing with dynamic route parameter support.
+ */
+export function pathFromKey(key) {
+    const relativePath = key.replace(/^\.\/pages\//, '');
+    const parts = relativePath.split('/');
+    parts.pop();
+    if (parts.length === 0) {
+        return '/';
+    }
+    if (parts.length === 1 && parts[0] === 'index') {
+        return '/';
+    }
+    return '/' + parts.map(segmentToPattern).join('/');
+}
+function segmentToPattern(segment) {
+    const insideBrackets = segment.match(/^\[(.+)\]$/);
+    if (insideBrackets) {
+        const content = insideBrackets[1];
+        if (content.startsWith('...')) {
+            const paramName = content.slice(3) || 'path';
+            return `:${paramName}(.*)`;
+        }
+        if (content.endsWith('?')) {
+            const paramName = content.slice(0, -1);
+            return `:${paramName}?`;
+        }
+        return `:${content}`;
+    }
+    return segment;
+}
+function extractParamNames(filePath) {
+    const params = [];
+    const parts = filePath.split('/');
+    for (const part of parts) {
+        const match = part.match(/^\[([^?\]]+)\??\]$|^\[\.\.\.([^\]]+)\]$/);
+        if (match) {
+            params.push((match[1] || match[2] || 'path'));
+        }
+    }
+    return params;
+}
+function buildRegexPattern(path) {
+    let pattern = path.replace(/\//g, '\\/');
+    pattern = pattern.replace(/:([^/(]+)\(\.\*\)/g, '([^/]+(?:/[^/]+)*)');
+    pattern = pattern.replace(/\/:([^/(]+)\?/g, '(?:/([^/]+))?');
+    pattern = pattern.replace(/:([^/(\s]+)/g, '([^/]+)');
+    return '^' + pattern + '$';
+}
+export function matchRoute(pattern, path) {
+    const paramNames = [];
+    const paramRegex = /:([^/?(]+)/g;
+    let match;
+    while ((match = paramRegex.exec(pattern)) !== null) {
+        paramNames.push(match[1]);
+    }
+    const regex = new RegExp(buildRegexPattern(pattern));
+    const matches = path.match(regex);
+    if (!matches) {
+        return null;
+    }
+    const params = {};
+    for (let index = 0; index < paramNames.length; index++) {
+        const value = matches[index + 1];
+        if (value !== undefined) {
+            params[paramNames[index]] = value;
+        }
+    }
+    return { params, pattern };
+}
+export function isDynamicRoute(path) {
+    return path.includes(':');
+}
+function componentFromModule(mod, key) {
+    if (typeof mod.default === 'function')
+        return mod.default;
+    const named = Object.values(mod).find((value) => typeof value === 'function');
+    if (!named) {
+        throw new Error(`[metaowl] No component export found in "${key}"`);
+    }
+    return named;
+}
+export function buildRoutes(modules) {
+    const routes = [];
+    for (const [key, mod] of Object.entries(modules)) {
+        const derivedPath = pathFromKey(key);
+        const component = componentFromModule(mod, key);
+        const routeConfig = component.route || {};
+        const routePath = typeof routeConfig.path === 'string' ? routeConfig.path : derivedPath;
+        const routeName = routePath === '/'
+            ? 'index'
+            : routePath.slice(1).replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+        const route = {
+            name: routeName,
+            path: [routePath],
+            component,
+            params: extractParamNames(key),
+            meta: component.route?.meta || {}
+        };
+        if (component.route) {
+            Object.assign(route, component.route);
+            route.path = [typeof route.path === 'string' ? route.path : routePath];
+            route.meta = route.meta || {};
+        }
+        routes.push(route);
+    }
+    routes.sort((left, right) => {
+        const leftPath = left.path[0];
+        const rightPath = right.path[0];
+        const leftIsCatchAll = leftPath.includes('(.*)');
+        const rightIsCatchAll = rightPath.includes('(.*)');
+        if (!leftIsCatchAll && rightIsCatchAll)
+            return -1;
+        if (leftIsCatchAll && !rightIsCatchAll)
+            return 1;
+        const leftIsDynamic = isDynamicRoute(leftPath);
+        const rightIsDynamic = isDynamicRoute(rightPath);
+        if (!leftIsDynamic && rightIsDynamic)
+            return -1;
+        if (leftIsDynamic && !rightIsDynamic)
+            return 1;
+        if (leftIsDynamic && rightIsDynamic) {
+            const leftSegments = leftPath.split('/').length;
+            const rightSegments = rightPath.split('/').length;
+            if (leftSegments !== rightSegments)
+                return rightSegments - leftSegments;
+            const leftParamCount = left.params?.length || 0;
+            const rightParamCount = right.params?.length || 0;
+            return leftParamCount - rightParamCount;
+        }
+        return 0;
+    });
+    return routes;
+}
+export function findRoute(routes, path) {
+    for (const route of routes) {
+        for (const routePath of route.path) {
+            const match = matchRoute(routePath, path);
+            if (match) {
+                return {
+                    ...route,
+                    matchedPath: routePath,
+                    params: match.params
+                };
+            }
+        }
+    }
+    return null;
+}
+export function generateUrl(routes, name, params = {}) {
+    const route = routes.find((candidate) => candidate.name === name);
+    if (!route) {
+        throw new Error(`[metaowl] Route "${name}" not found`);
+    }
+    let path = route.path[0];
+    for (const [key, value] of Object.entries(params)) {
+        path = path.replace(`:${key}`, value);
+        path = path.replace(`:${key}?`, value);
+    }
+    return path.replace(/\/:[^/]+\?/g, '').replace(/\?$/, '');
+}
+export function validateRouteParams(route, params) {
+    const required = route.params || [];
+    const provided = Object.keys(params);
+    const missing = required.filter((param) => !provided.includes(param));
+    const extra = provided.filter((param) => !required.includes(param));
+    return {
+        valid: missing.length === 0,
+        missing,
+        extra
+    };
+}
+export function parseCurrentRoute(routes) {
+    return findRoute(routes, document.location.pathname);
+}
+export function defineRoute(config) {
+    return config;
+}
+export function route(config) {
+    return function decorator(componentClass) {
+        componentClass.route = config;
+        return componentClass;
+    };
+}
+export function createCatchAllRoute(component, options = {}) {
+    return {
+        name: options.name || '404',
+        path: ['/:path(.*)'],
+        component,
+        params: ['path'],
+        meta: { ...options.meta, catchAll: true }
+    };
+}
+export function createRedirectRoute(from, to) {
+    const name = from.replace(/^\//, '').replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-');
+    return {
+        name: `redirect-${name}`,
+        path: [from],
+        redirect: to,
+        component: null,
+        meta: {}
+    };
+}

package/build/runtime/modules/forms.js

@@ -0,0 +1,193 @@
+/**
+ * @module Forms
+ *
+ * Form handling and validation for MetaOwl applications.
+ */
+import { reactive } from '@odoo/owl';
+function getChangedValue(event) {
+    if (typeof event === 'object' && event !== null && 'target' in event) {
+        const target = event.target;
+        return target?.value ?? event;
+    }
+    return event;
+}
+export function useForm(fieldsConfig = {}) {
+    const fields = {};
+    const errors = {};
+    const touched = {};
+    const dirty = {};
+    const validating = {};
+    for (const [name, config] of Object.entries(fieldsConfig)) {
+        const initialValue = config?.default ?? '';
+        fields[name] = initialValue;
+        errors[name] = null;
+        touched[name] = false;
+        dirty[name] = false;
+        validating[name] = false;
+    }
+    const state = reactive({
+        fields,
+        errors,
+        touched,
+        dirty,
+        validating,
+        isSubmitting: false,
+        isValidating: false,
+        submitCount: 0
+    });
+    async function validateField(name) {
+        const config = fieldsConfig[name];
+        if (!config?.validation) {
+            state.errors[name] = null;
+            return true;
+        }
+        const value = state.fields[name];
+        const validatorList = Array.isArray(config.validation)
+            ? config.validation
+            : [config.validation];
+        for (const validator of validatorList) {
+            const result = validator(value, state.fields);
+            if (result !== true) {
+                state.errors[name] = result || 'Invalid';
+                return false;
+            }
+        }
+        if (config.asyncValidation) {
+            state.validating[name] = true;
+            state.isValidating = true;
+            try {
+                const result = await config.asyncValidation(value, state.fields);
+                if (result !== true) {
+                    state.errors[name] = result || 'Invalid';
+                    return false;
+                }
+            }
+            finally {
+                state.validating[name] = false;
+                state.isValidating = Object.values(state.validating).some(Boolean);
+            }
+        }
+        state.errors[name] = null;
+        return true;
+    }
+    async function validateAll() {
+        const results = await Promise.all(Object.keys(fieldsConfig).map((name) => validateField(name)));
+        return results.every(Boolean);
+    }
+    const controller = {
+        fields: state.fields,
+        errors: state.errors,
+        touched: state.touched,
+        dirty: state.dirty,
+        validating: state.validating,
+        isSubmitting: state.isSubmitting,
+        isValidating: state.isValidating,
+        submitCount: state.submitCount,
+        get isValid() {
+            return Object.values(state.errors).every((error) => error === null);
+        },
+        get isDirty() {
+            return Object.values(state.dirty).some(Boolean);
+        },
+        get isTouched() {
+            return Object.values(state.touched).some(Boolean);
+        },
+        setValue(name, value) {
+            state.fields[name] = value;
+            state.dirty[name] = value !== (fieldsConfig[name]?.default ?? '');
+        },
+        setTouched(name) {
+            state.touched[name] = true;
+        },
+        setAllTouched() {
+            for (const name of Object.keys(fieldsConfig)) {
+                state.touched[name] = true;
+            }
+        },
+        validateField,
+        validate: validateAll,
+        reset() {
+            for (const [name, config] of Object.entries(fieldsConfig)) {
+                state.fields[name] = config?.default ?? '';
+                state.errors[name] = null;
+                state.touched[name] = false;
+                state.dirty[name] = false;
+            }
+            state.isSubmitting = false;
+            state.submitCount = 0;
+        },
+        handleSubmit(onSubmit, options = {}) {
+            const { validate = true } = options;
+            return async (...args) => {
+                state.isSubmitting = true;
+                state.submitCount++;
+                try {
+                    if (validate) {
+                        controller.setAllTouched();
+                        const isValid = await controller.validate();
+                        if (!isValid) {
+                            state.isSubmitting = false;
+                            return;
+                        }
+                    }
+                    await onSubmit({ ...state.fields }, ...args);
+                }
+                finally {
+                    state.isSubmitting = false;
+                }
+            };
+        },
+        register(name) {
+            return {
+                value: state.fields[name],
+                onChange: (event) => controller.setValue(name, getChangedValue(event)),
+                onBlur: () => {
+                    controller.setTouched(name);
+                    void controller.validateField(name);
+                },
+                error: state.touched[name] ? state.errors[name] : null
+            };
+        }
+    };
+    return controller;
+}
+export const validators = {
+    required: (message = 'Required') => (value) => Boolean(value) || message,
+    minLength: (min, message) => (value) => (value?.length ?? 0) >= min || message || `Min ${min} characters`,
+    maxLength: (max, message) => (value) => (value?.length ?? 0) <= max || message || `Max ${max} characters`,
+    min: (min, message) => (value) => Number(value) >= min || message || `Min ${min}`,
+    max: (max, message) => (value) => Number(value) <= max || message || `Max ${max}`,
+    email: (message = 'Invalid email') => (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value ?? '')) || message,
+    url: (message = 'Invalid URL') => (value) => /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})[/\w .-]*\/?$/.test(String(value ?? '')) || message,
+    pattern: (regex, message = 'Invalid format') => (value) => regex.test(String(value ?? '')) || message,
+    match: (field, message) => (value, values) => value === values[field] || message || 'Fields do not match'
+};
+export function createSchema(schema) {
+    const fieldsConfig = {};
+    for (const [name, fieldValidators] of Object.entries(schema)) {
+        const validatorArray = Array.isArray(fieldValidators) ? fieldValidators : [fieldValidators];
+        fieldsConfig[name] = {
+            default: '',
+            validation: (value, values) => {
+                for (const validator of validatorArray) {
+                    const result = validator(value, values);
+                    if (result !== true)
+                        return result;
+                }
+                return true;
+            }
+        };
+    }
+    return fieldsConfig;
+}
+export function fieldProps(form, name) {
+    return {
+        value: form.fields[name],
+        error: form.touched[name] ? form.errors[name] : null,
+        onChange: (value) => form.setValue(name, getChangedValue(value)),
+        onBlur: () => {
+            form.setTouched(name);
+            void form.validateField(name);
+        }
+    };
+}

package/build/runtime/modules/i18n.js

@@ -0,0 +1,167 @@
+/**
+ * @module i18n
+ *
+ * Internationalization (i18n) support for MetaOwl applications.
+ */
+import { reactive } from '@odoo/owl';
+const state = reactive({
+    locale: 'en',
+    fallbackLocale: 'en',
+    messages: {},
+    loading: false
+});
+const pluralRules = new Map();
+export function setPluralizationRule(locale, rule) {
+    pluralRules.set(locale, rule);
+}
+function defaultPluralRule(count) {
+    if (count === 0)
+        return 'zero';
+    if (count === 1)
+        return 'one';
+    return 'other';
+}
+function getPluralForm(count, locale) {
+    const rule = pluralRules.get(locale) || defaultPluralRule;
+    return rule(count);
+}
+export function configureI18n(config) {
+    if (config.locale) {
+        state.locale = config.locale;
+        document.documentElement.lang = config.locale;
+    }
+    if (config.fallbackLocale) {
+        state.fallbackLocale = config.fallbackLocale;
+    }
+    if (config.messages) {
+        state.messages = config.messages;
+    }
+}
+export function getLocale() {
+    return state.locale;
+}
+export async function setLocale(locale) {
+    state.locale = locale;
+    document.documentElement.lang = locale;
+}
+export async function loadLocaleMessages(locale, messages) {
+    state.loading = true;
+    try {
+        const loaded = await messages;
+        if (!state.messages[locale]) {
+            state.messages[locale] = {};
+        }
+        Object.assign(state.messages[locale], loaded);
+    }
+    finally {
+        state.loading = false;
+    }
+}
+export function t(key, values = {}, defaultMessage) {
+    const locale = state.locale;
+    const fallbackLocale = state.fallbackLocale;
+    let message = getMessage(key, locale);
+    if (!message && locale !== fallbackLocale) {
+        message = getMessage(key, fallbackLocale);
+    }
+    if (!message) {
+        return defaultMessage || key;
+    }
+    if (isPluralMessage(message)) {
+        const countValue = values.n ?? values.count ?? 0;
+        const count = typeof countValue === 'number' ? countValue : Number(countValue);
+        const form = getPluralForm(Number.isNaN(count) ? 0 : count, locale);
+        message = message[form] || message.other || message.one || key;
+    }
+    if (typeof message !== 'string') {
+        return defaultMessage || key;
+    }
+    return interpolate(message, values);
+}
+function getMessage(key, locale) {
+    const parts = key.split('.');
+    let current = state.messages[locale];
+    for (const part of parts) {
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function isPluralMessage(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return false;
+    }
+    const keys = Object.keys(message);
+    return keys.some((key) => ['zero', 'one', 'two', 'few', 'many', 'other'].includes(key));
+}
+function interpolate(message, values) {
+    return message.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+        return values[key] !== undefined ? String(values[key]) : match;
+    });
+}
+export function formatDate(date, options = {}) {
+    return new Intl.DateTimeFormat(state.locale, options).format(new Date(date));
+}
+export function formatNumber(value, options = {}) {
+    return new Intl.NumberFormat(state.locale, options).format(value);
+}
+export function formatCurrency(amount, currency, options = {}) {
+    return new Intl.NumberFormat(state.locale, {
+        style: 'currency',
+        currency,
+        ...options
+    }).format(amount);
+}
+export function formatRelativeTime(date, style = 'long') {
+    const targetDate = new Date(date);
+    const now = new Date();
+    const diff = targetDate.getTime() - now.getTime();
+    const seconds = Math.round(diff / 1000);
+    const minutes = Math.round(seconds / 60);
+    const hours = Math.round(minutes / 60);
+    const days = Math.round(hours / 24);
+    const rtf = new Intl.RelativeTimeFormat(state.locale, { style });
+    if (Math.abs(seconds) < 60)
+        return rtf.format(seconds, 'second');
+    if (Math.abs(minutes) < 60)
+        return rtf.format(minutes, 'minute');
+    if (Math.abs(hours) < 24)
+        return rtf.format(hours, 'hour');
+    return rtf.format(days, 'day');
+}
+export const i18n = {
+    get locale() { return state.locale; },
+    get fallbackLocale() { return state.fallbackLocale; },
+    get loading() { return state.loading; },
+    get messages() { return state.messages; },
+    configure: configureI18n,
+    setLocale,
+    t,
+    formatDate,
+    formatNumber,
+    formatCurrency,
+    formatRelativeTime
+};
+export function createNamespacedT(namespace) {
+    return (key, values) => t(`${namespace}.${key}`, values);
+}
+setPluralizationRule('de', (count) => {
+    if (count === 0)
+        return 'zero';
+    if (count === 1)
+        return 'one';
+    return 'other';
+});
+setPluralizationRule('ru', (count) => {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 === 1 && mod100 !== 11)
+        return 'one';
+    if ([2, 3, 4].includes(mod10) && ![12, 13, 14].includes(mod100))
+        return 'few';
+    if (mod10 === 0 || [5, 6, 7, 8, 9].includes(mod10) || [11, 12, 13, 14].includes(mod100))
+        return 'many';
+    return 'other';
+});