metaowl 0.4.0 → 0.5.0

package/index.js

@@ -1,328 +0,0 @@
-import { mountApp } from './modules/app-mounter.js'
-import { buildRoutes } from './modules/file-router.js'
-import { processRoutes, setSpaMode, _setSpaNavigationCallback } from './modules/router.js'
-import { discoverLayouts, buildLayouts, setDefaultLayout } from './modules/layouts.js'
-
-export { default as Fetch } from './modules/fetch.js'
-export { default as Cache } from './modules/cache.js'
-export { configureOwl } from './modules/app-mounter.js'
-export * as Meta from './modules/meta.js'
-export { buildRoutes }
-export { Store, createPersistencePlugin, createStore } from './modules/store.js'
-export {
-  registerLayout,
-  unregisterLayout,
-  getLayout,
-  hasLayout,
-  getLayoutNames,
-  setDefaultLayout,
-  getDefaultLayout,
-  resolveLayout,
-  setRouteLayout,
-  getRouteLayout,
-  createLayoutWrapper,
-  mountWithLayout,
-  getCurrentLayout,
-  subscribeToLayouts,
-  clearLayouts,
-  layout,
-  defineLayout,
-  buildLayouts,
-  discoverLayouts
-} from './modules/layouts.js'
-export {
-  processRoutes,
-  beforeEach,
-  afterEach,
-  getCurrentRoute,
-  getPreviousRoute,
-  isNavigating,
-  cancelNavigation,
-  navigate,
-  navigateTo,
-  push,
-  replace,
-  back,
-  forward,
-  go,
-  router,
-  setSpaMode,
-  isSpaMode
-} from './modules/router.js'
-export { Link, registerLinkTemplate } from './modules/link.js'
-export {
-  matchRoute,
-  isDynamicRoute,
-  findRoute,
-  generateUrl,
-  validateRouteParams,
-  createCatchAllRoute,
-  createRedirectRoute,
-  defineRoute,
-  route
-} from './modules/file-router.js'
-export {
-  onError,
-  setErrorContext,
-  getErrorContext,
-  clearErrorContext,
-  captureError,
-  initGlobalErrorHandling,
-  errorBoundary
-} from './modules/error-boundary.js'
-export {
-  configureI18n,
-  t,
-  getLocale,
-  setLocale,
-  i18n,
-  loadLocaleMessages,
-  formatDate,
-  formatNumber,
-  formatCurrency,
-  formatRelativeTime,
-  createNamespacedT
-} from './modules/i18n.js'
-export {
-  useForm,
-  validators,
-  createSchema,
-  fieldProps
-} from './modules/forms.js'
-export {
-  OdooService,
-  configure,
-  authenticate,
-  logout,
-  searchRead,
-  call,
-  read,
-  create,
-  write,
-  unlink,
-  searchCount,
-  listDatabases,
-  versionInfo,
-  isAuthenticated,
-  getSession,
-  onAuthChange
-} from './modules/odoo-rpc.js'
-export {
-  useAuth,
-  useLocalStorage,
-  useFetch,
-  useDebounce,
-  useThrottle,
-  useWindowSize,
-  useOnlineStatus,
-  useAsyncState,
-  useCache,
-  Composables
-} from './modules/composables.js'
-export {
-  createMockStore,
-  mockRouter,
-  mountComponent,
-  wait,
-  nextTick,
-  flushPromises,
-  userEvent,
-  dom,
-  TestUtils
-} from './modules/test-utils.js'
-export {
-  generateSitemap,
-  generateRobotsTxt,
-  jsonLd,
-  createCanonicalUrl,
-  generateOpenGraph,
-  generateTwitterCard,
-  validateSitemap,
-  getPriorityByDepth,
-  generateSitemapIndex,
-  SEO
-} from './modules/seo.js'
-export {
-  generateManifest,
-  registerServiceWorker,
-  unregisterServiceWorker,
-  isStandalone,
-  isOnline,
-  subscribeToConnectivity,
-  requestPersistentStorage,
-  getStorageInfo,
-  sync,
-  subscribeToPush,
-  unsubscribeFromPush,
-  showNotification,
-  cache,
-  checkCapabilities,
-  PWA
-} from './modules/pwa.js'
-
-/**
- * Global routes reference for SPA navigation.
- * @type {object[]|null}
- */
-let _appRoutes = null
-
-/**
- * Monotonically-increasing navigation counter.
- * Incremented on every navigation attempt; lets us discard stale navigations
- * that complete AFTER a newer one was already triggered.
- * @type {number}
- */
-let _navSeq = 0
-
-/**
- * Promise of the currently-running mountApp call.
- * Used to serialize mounts: a new navigation waits for the in-progress mount
- * to finish, then checks if it is still the latest before mounting itself.
- * This prevents concurrent OWL App instances on the same element.
- * @type {Promise<void>|null}
- */
-let _mountingPromise = null
-
-function _handle404() {
-  const el = document.getElementById('metaowl')
-  if (el) {
-    el.innerHTML = [
-      '<div style="font-family:sans-serif;padding:3rem;text-align:center">',
-      '<h1 style="font-size:4rem;font-weight:700;margin:0;color:#6b7280">404</h1>',
-      '<p style="font-size:1.25rem;color:#9ca3af;margin-top:0.5rem">Page not found</p>',
-      '<p style="margin-top:2rem"><a href="/" style="color:#3b82f6;text-decoration:none">← Go home</a></p>',
-      '</div>'
-    ].join('')
-  }
-}
-
-/**
- * SPA navigation callback.
- * Called when navigateTo() is used.
- *
- * @param {string} path - The target path
- * @returns {Promise<void>}
- */
-async function _spaNavigate(path) {
-  if (!_appRoutes) {
-    console.error('[metaowl] Routes not available for SPA navigation')
-    return
-  }
-
-  const seq = ++_navSeq
-
-  let route
-  try {
-    route = await processRoutes(_appRoutes, path)
-  } catch (error) {
-    if (seq !== _navSeq) return
-    if (error.message && error.message.startsWith('No route found')) {
-      console.warn('[metaowl]', error.message)
-      _handle404()
-    } else {
-      throw error
-    }
-    return
-  }
-
-  // Bail early if a newer navigation overtook us while processRoutes was running
-  if (seq !== _navSeq || !route) return
-
-  // Wait for any in-progress mount to finish before starting our own.
-  // This is the key serialization: it ensures only one OWL App mounts at a time.
-  if (_mountingPromise) {
-    await _mountingPromise.catch(() => {})
-    // After waiting, check again — a newer navigation may have started
-    if (seq !== _navSeq) return
-  }
-
-  // Claim the mount slot
-  _mountingPromise = mountApp(route)
-  try {
-    await _mountingPromise
-  } finally {
-    _mountingPromise = null
-  }
-}
-
-/**
- * Boots the metaowl application.
- *
- * When called without arguments inside a Vite project, the `metaowl:app`
- * plugin transform automatically rewrites `boot()` to
- * `boot(import.meta.glob('./pages/**\/*.js', { eager: true }))` at build time.
- *
- * Can also be called explicitly with:
- *   - An import.meta.glob result (file-based routing):
- *       boot(import.meta.glob('./pages/**\/*.js', { eager: true }))
- *   - A manual route array:
- *       boot([{ name: 'index', path: ['/'], component: IndexPage }])
- *
- * @param {Record<string, object>|object[]} [routesOrModules]
- * @param {object} [options] - Boot options
- * @param {boolean} [options.spa=true] - Enable SPA navigation mode
- */
-export async function boot(routesOrModules = {}, layoutsOrModules = null, options = {}) {
-  const { spa = true } = options
-
-  // Auto-discover layouts
-  try {
-    if (layoutsOrModules && typeof layoutsOrModules === 'object' && !Array.isArray(layoutsOrModules)) {
-      // Use layouts provided by Vite plugin transformation
-      buildLayouts(layoutsOrModules)
-      setDefaultLayout('default')
-    } else if (typeof layoutsOrModules === 'object' && layoutsOrModules?.spa !== undefined) {
-      // Options object passed as second argument
-      Object.assign(options, layoutsOrModules)
-    } else {
-      await discoverLayouts()
-    }
-  } catch (e) {
-    console.warn('[metaowl] Could not auto-discover layouts:', e.message)
-  }
-
-  const routes = Array.isArray(routesOrModules)
-    ? routesOrModules
-    : buildRoutes(routesOrModules)
-
-  // Store routes for SPA navigation
-  _appRoutes = routes
-
-  // Enable SPA mode
-  if (spa) {
-    setSpaMode(true)
-    _setSpaNavigationCallback(_spaNavigate)
-
-    // Register global navigateTo handler for Link component
-    window.__metaowlNavigate = _spaNavigate
-
-    // Listen to PopState events (Browser Back/Forward)
-    window.addEventListener('popstate', (event) => {
-      const path = document.location.pathname
-      _spaNavigate(path)
-    })
-  }
-
-  let route
-  try {
-    route = await processRoutes(routes)
-  } catch (error) {
-    if (error.message && error.message.startsWith('No route found')) {
-      console.warn('[metaowl]', error.message)
-      const el = document.getElementById('metaowl')
-      if (el) {
-        el.innerHTML = [
-          '<div style="font-family:sans-serif;padding:3rem;text-align:center">',
-          '<h1 style="font-size:4rem;font-weight:700;margin:0;color:#6b7280">404</h1>',
-          '<p style="font-size:1.25rem;color:#9ca3af;margin-top:0.5rem">Page not found</p>',
-          '<p style="margin-top:2rem"><a href="/" style="color:#3b82f6;text-decoration:none">← Go home</a></p>',
-          '</div>'
-        ].join('')
-      }
-      return
-    }
-    throw error
-  }
-
-  await mountApp(route)
-}

package/modules/app-mounter.js

@@ -1,104 +0,0 @@
-/**
- * @module AppMounter
- *
- * OWL application mounting with template merging.
- * Handles the low-level mounting of components into the DOM with
- * merged XML templates from the build process.
- */
-import { mount } from '@odoo/owl'
-import { mergeTemplates } from './templates-manager.js'
-import { resolveLayout, getLayout, mountWithLayout } from './layouts.js'
-import { Link } from './link.js'
-
-const _defaults = {
-  warnIfNoStaticProps: true,
-  willStartTimeout: 10000,
-  translatableAttributes: ['title', 'placeholder', 'label', 'alt']
-}
-
-let _config = { ..._defaults }
-
-/**
- * Reference to the currently mounted OWL App instance.
- * Destroyed before each new mount to prevent zombie app accumulation.
- * @type {import('@odoo/owl').App|null}
- */
-let _currentApp = null
-
-/**
- * Override or extend the default OWL mount configuration.
- * Call before boot() in your project's metaowl.js.
- *
- * @param {object} config - Partial OWL config merged over the defaults.
- */
-export function configureOwl(config) {
-  _config = { ..._defaults, ...config }
-}
-
-/**
- * Mount the resolved route's OWL component into `#app`.
- *
- * Loads and merges all XML templates (collected at build time by the
- * metaowl Vite plugin via the `COMPONENTS` define), then mounts the component
- * using the active OWL config.
- *
- * @param {object[]} route - Single-element array returned by `processRoutes()`.
- * @returns {Promise<void>}
- */
-/**
- * Cached merged templates string. Computed once on first navigation;
- * COMPONENTS (the list of XML files) never changes at runtime so the
- * result is the same for every mount.
- * @type {string|null}
- */
-let _cachedTemplates = null
-
-export async function mountApp(route) {
-  // Load and cache templates on first call; reuse on every subsequent navigation.
-  // Without caching, every navigation re-fetches all XML template files.
-  const components = typeof COMPONENTS !== 'undefined' ? COMPONENTS : []
-  if (!_cachedTemplates) {
-    _cachedTemplates = await mergeTemplates(components)
-  }
-  const templates = _cachedTemplates
-  const mountElement = document.getElementById('metaowl')
-
-  // Destroy the previous OWL App before mounting a new one.
-  // Without this, every navigation leaves a zombie app running in the background
-  // (scheduler, reactive effects, event listeners) that accumulates and causes freezes.
-  if (_currentApp) {
-    try { _currentApp.destroy() } catch (_) {}
-    _currentApp = null
-  }
-  mountElement.innerHTML = ''
-
-  const pageComponent = route[0].component
-  const pagePath = route[0].path
-
-  // Check for layout
-  const layoutName = resolveLayout(pageComponent, pagePath)
-  const LayoutClass = getLayout(layoutName)
-
-  // Base mount configuration with built-in components
-  const baseConfig = {
-    ..._config,
-    templates,
-    components: {
-      Link,
-      't-link': Link
-    }
-  }
-
-  let instance
-  if (LayoutClass) {
-    // Mount with layout
-    instance = await mountWithLayout(pageComponent, mountElement, { routePath: pagePath, ...baseConfig })
-  } else {
-    // Mount without layout
-    instance = await mount(pageComponent, mountElement, baseConfig)
-  }
-
-  // Store OWL App reference so we can destroy it before the next navigation.
-  // instance.__owl__.app is the underlying App object that owns the scheduler.
-  _currentApp = instance?.__owl__?.app ?? null
-}

package/modules/auto-import.js

@@ -1,225 +0,0 @@
-/**
- * @module AutoImport
- *
- * Automatic component importing for MetaOwl applications.
- *
- * Features:
- * - Auto-discovers components from src/components/
- * - Generates import statements at build time
- * - Optional - disabled by default
- *
- * Configuration in vite.config.js:
- *   metaowlConfig({
- *     autoImport: {
- *       enabled: true,
- *       componentsDir: 'src/components',
- *       pattern: '*.js'
- *     }
- *   })
- *
- * Usage:
- * - Components are automatically available in templates
- * - No manual import needed
- */
-
-import { globSync } from 'glob'
-import { resolve, relative, basename, extname, dirname } from 'node:path'
-
-/**
- * Registry of auto-discovered components.
- */
-let _importMap = null
-
-/**
- * Generate component import map from directory.
- *
- * @param {string} componentsDir - e.g. 'src/components'
- * @returns {Map<string, string>} Map of PascalCase names to import paths
- */
-export function generateComponentMap(componentsDir, pattern = '*.js') {
-  const map = new Map()
-  const globPattern = pattern.includes('/') ? pattern : `${componentsDir}/${pattern}`
-  const files = globSync(globPattern)
-
-  for (const file of files) {
-    if (file.includes('.test.') || file.includes('.spec.')) continue
-
-    const name = getComponentName(file)
-    if (!name) continue
-
-    const importPath = `/@components/${relative(componentsDir, file).replace(/\\/g, '/')}`
-    map.set(name, importPath)
-  }
-
-  return map
-}
-
-function getComponentName(filePath) {
-  const ext = extname(filePath)
-  const base = basename(filePath, ext)
-  
-  if (basename(filePath) === base + ext) {
-    return base
-  }
-  
-  const dir = relative(process.cwd(), filePath).split('/')
-  if (base === 'index' && dir.length > 1) {
-    return toPascalCase(dir[dir.length - 2])
-  }
-  
-  return toPascalCase(base)
-}
-
-function toPascalCase(str) {
-  return str
-    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-    .replace(/^[a-z]/, char => char.toUpperCase())
-}
-
-/**
- * Scan components directory for component files.
- *
- * @param {string} componentsDir - Directory to scan
- * @param {object} options - Options
- * @param {string} options.pattern - Glob pattern
- * @returns {Promise<string[]>} Array of component names
- */
-export async function scanComponents(componentsDir, options = {}) {
-  const { pattern = '*.js' } = options
-  const absoluteDir = resolve(componentsDir)
-  const fs = await import('fs/promises')
-  const { join } = await import('path')
-
-  const components = []
-
-  async function scanDir(dir) {
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true })
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name)
-
-        if (entry.isDirectory()) {
-          // Recursively scan subdirectories
-          await scanDir(fullPath)
-        } else if (entry.isFile() && entry.name.endsWith('.js')) {
-          // Skip test files
-          if (entry.name.includes('.test.') || entry.name.includes('.spec.')) continue
-
-          const name = getComponentName(fullPath)
-          if (name && !components.includes(name)) {
-            components.push(name)
-          }
-        }
-      }
-    } catch {
-      // Directory doesn't exist or can't be read
-    }
-  }
-
-  await scanDir(absoluteDir)
-  return components
-}
-
-/**
- * Generate TypeScript declarations file for components.
- *
- * @param {string[]} components - Array of component names
- * @param {string} outputPath - Path to write .d.ts file
- * @returns {Promise<void>}
- */
-export async function generateComponentDts(components, outputPath) {
-  const { writeFileSync, mkdirSync } = await import('fs')
-  const { join } = await import('path')
-
-  // Ensure directory exists
-  const dir = dirname(outputPath)
-  mkdirSync(dir, { recursive: true })
-
-  const declarations = components.map(name =>
-    `  ${name}: typeof import('./components/${name}/${name}.js').default`
-  ).join('\n')
-
-  const content = `// Auto-generated by metaowl - do not edit\ndeclare module '@metaowl/components' {\n${declarations}\n}\n`
-
-  writeFileSync(outputPath, content, 'utf-8')
-}
-
-export function generateImports(componentMap) {
-  const lines = []
-  for (const [name, path] of componentMap) {
-    lines.push(`import ${name} from '${path}'`)
-  }
-  return lines.join('\n')
-}
-
-export function generateComponentsObject(componentMap) {
-  const entries = Array.from(componentMap.keys())
-    .map(name => `  ${name}`)
-    .join(',\n')
-  return `{\n${entries}\n}`
-}
-
-export function createAutoImportPlugin(options = {}) {
-  const {
-    enabled = false,
-    componentsDir = 'src/components',
-    pattern = '**/*.js'
-  } = options
-
-  if (!enabled) {
-    return null
-  }
-
-  _importMap = generateComponentMap(componentsDir, `${componentsDir}/${pattern}`)
-
-  return {
-    name: 'metaowl:auto-import',
-    enforce: 'pre',
-
-    config(config) {
-      config.resolve ||= {}
-      config.resolve.alias ||= {}
-      config.resolve.alias['/@components'] = resolve(process.cwd(), componentsDir)
-    },
-
-    transform(code, id) {
-      if (!id.includes('/pages/') || !/\.[jt]s$/.test(id)) {
-        return null
-      }
-
-      if (!code.includes('/* auto-import */') && !code.includes('// auto-import')) {
-        return null
-      }
-
-      const imports = generateImports(_importMap)
-      const componentsObj = generateComponentsObject(_importMap)
-
-      let transformed = imports + '\n\n' + code
-
-      if (transformed.includes('extends Component')) {
-        transformed = transformed.replace(
-          /(class\s+\w+\s+extends\s+Component\s*\{)/,
-          `$1\n  static components = ${componentsObj}\n`
-        )
-      }
-
-      return { code: transformed, map: null }
-    }
-  }
-}
-
-export function registerAutoImport(name, path) {
-  if (!_importMap) {
-    _importMap = new Map()
-  }
-  _importMap.set(name, path)
-}
-
-export function getAutoImportMap() {
-  return _importMap ? new Map(_importMap) : null
-}
-
-export function clearAutoImports() {
-  _importMap = null
-}

package/modules/cache.js

@@ -1,59 +0,0 @@
-/**
- * @module Cache
- *
- * Async-style localStorage wrapper.
- *
- * Values are automatically JSON-serialised on write and deserialised on read.
- * All methods return Promises so they are interchangeable with IndexedDB-based
- * alternatives without changing call-sites.
- */
-export default class Cache {
-  /**
-   * Retrieve a value by key.
-   *
-   * @param {string} key
-   * @returns {Promise<any>} Parsed value, or `null` if the key does not exist.
-   */
-  static async get(key) {
-    return JSON.parse(localStorage.getItem(key))
-  }
-
-  /**
-   * Store a value under the given key.
-   *
-   * @param {string} key
-   * @param {any} value - Must be JSON-serialisable.
-   * @returns {Promise<void>}
-   */
-  static async set(key, value) {
-    localStorage.setItem(key, JSON.stringify(value))
-  }
-
-  /**
-   * Remove a single entry.
-   *
-   * @param {string} key
-   * @returns {Promise<void>}
-   */
-  static async remove(key) {
-    localStorage.removeItem(key)
-  }
-
-  /**
-   * Remove **all** entries from localStorage.
-   *
-   * @returns {Promise<void>}
-   */
-  static async clear() {
-    localStorage.clear()
-  }
-
-  /**
-   * Return all keys currently stored in localStorage.
-   *
-   * @returns {Promise<string[]>}
-   */
-  static async keys() {
-    return Array.from({ length: localStorage.length }, (_, i) => localStorage.key(i))
-  }
-}