qdadm 1.13.1 → 1.19.2

package/src/i18n/defaults/DefaultCoreProvider.ts

@@ -0,0 +1,28 @@
+/**
+ * Default core provider — ships qdadm's `core.*` defaults (EN + FR) as a
+ * `LazyTranslationProvider` configured with a YAML loader.
+ *
+ * The YAML files (`core.en.yml`, `core.fr.yml`) are imported via Vite's
+ * `?raw` query so the text is fetched on-demand, then parsed at runtime.
+ * Splitting the bundle by locale (and, in the future, by domain) keeps the
+ * provider tree-shakeable and translator-friendly.
+ *
+ * Adding a built-in locale = drop `core.<locale>.yml` next to this file and
+ * add it to the loader map below.
+ */
+
+import { LazyTranslationProvider } from '../LazyTranslationProvider'
+import { createYamlLoader } from '../loaders/yaml'
+
+export function createDefaultCoreProvider(): LazyTranslationProvider {
+  const yamlLoader = createYamlLoader({
+    en: () => import('./core.en.yml?raw'),
+    fr: () => import('./core.fr.yml?raw'),
+  })
+
+  return new LazyTranslationProvider({
+    name: 'default-core',
+    loaders: [yamlLoader],
+    locales: ['en', 'fr'],
+  })
+}

package/src/i18n/defaults/core.en.yml

@@ -0,0 +1,55 @@
+core:
+  actions:
+    save: Save
+    cancel: Cancel
+    delete: Delete
+    edit: Edit
+    create: Create
+    update: Update
+    createAndClose: Create & Close
+    updateAndClose: Update & Close
+    add: Add
+    remove: Remove
+    submit: Submit
+    reset: Reset
+    back: Back
+    next: Next
+    previous: Previous
+    close: Close
+    confirm: Confirm
+    search: Search
+    filter: Filter
+    clear: Clear
+    refresh: Refresh
+    export: Export
+    import: Import
+  tooltips:
+    saveAndContinue: Save and continue editing
+    saveAndReturn: Save and return to list
+    unsavedChanges: Unsaved changes
+  placeholders:
+    search: Search…
+    noSelection: Click to select…
+  fields:
+    id: ID
+    created_at: Created at
+    updated_at: Updated at
+    created_by: Created by
+    updated_by: Updated by
+  messages:
+    empty: No items available
+    loading: Loading…
+    noResults: No results
+    noMatching: No matching items
+    saved: Saved
+    deleted: Deleted
+    created: Created
+    updated: Updated
+    confirmDelete: Are you sure you want to delete this item?
+  errors:
+    required: Required
+    tooShort: Too short (min {min})
+    tooLong: Too long (max {max})
+    invalid: Invalid value
+    notFound: Not found
+    unknown: An unknown error occurred

package/src/i18n/defaults/core.fr.yml

@@ -0,0 +1,55 @@
+core:
+  actions:
+    save: Enregistrer
+    cancel: Annuler
+    delete: Supprimer
+    edit: Modifier
+    create: Créer
+    update: Mettre à jour
+    createAndClose: Créer et fermer
+    updateAndClose: Mettre à jour et fermer
+    add: Ajouter
+    remove: Retirer
+    submit: Valider
+    reset: Réinitialiser
+    back: Retour
+    next: Suivant
+    previous: Précédent
+    close: Fermer
+    confirm: Confirmer
+    search: Rechercher
+    filter: Filtrer
+    clear: Effacer
+    refresh: Actualiser
+    export: Exporter
+    import: Importer
+  tooltips:
+    saveAndContinue: Enregistrer et continuer la modification
+    saveAndReturn: Enregistrer et revenir à la liste
+    unsavedChanges: Modifications non enregistrées
+  placeholders:
+    search: Rechercher…
+    noSelection: Cliquez pour sélectionner…
+  fields:
+    id: Identifiant
+    created_at: Créé le
+    updated_at: Modifié le
+    created_by: Créé par
+    updated_by: Modifié par
+  messages:
+    empty: Aucun élément
+    loading: Chargement…
+    noResults: Aucun résultat
+    noMatching: Aucune correspondance
+    saved: Enregistré
+    deleted: Supprimé
+    created: Créé
+    updated: Modifié
+    confirmDelete: Êtes-vous sûr de vouloir supprimer cet élément ?
+  errors:
+    required: Requis
+    tooShort: Trop court (min {min})
+    tooLong: Trop long (max {max})
+    invalid: Valeur invalide
+    notFound: Introuvable
+    unknown: Une erreur inconnue est survenue

package/src/i18n/index.ts

@@ -0,0 +1,55 @@
+/**
+ * qdadm i18n - public exports.
+ *
+ * ## Two providers to choose from
+ *
+ *   - **`LazyTranslationProvider`** — full bundle on `load(locale)`, split
+ *     across multiple loaders (one per file/domain) deep-merged on resolve.
+ *     Use when the locale bundle is reasonable to fetch up-front.
+ *
+ *   - **`IncrementalDomainProvider`** — one loader per top-level domain,
+ *     fetched on demand. `t()` on an unloaded domain returns the raw key
+ *     synchronously and emits `i18n:domain-loaded` once merged. Use for
+ *     large apps with rarely-used sections.
+ *
+ * Both support `createYamlLoader({ <locale>: () => import('./xx.yml?raw') })`
+ * for the typical "split YAML files in a directory" setup.
+ *
+ * See docs/todo-i18n.md for the broader design rationale.
+ */
+
+export { I18n } from './I18n'
+export type { I18nDeps } from './I18n'
+export { MessagesRegistry } from './MessagesRegistry'
+export { Resolver, snakeCaseToTitle } from './Resolver'
+export { InlineTranslationProvider } from './InlineTranslationProvider'
+export { defineStrategy, resolveStrategy, STRATEGIES } from './strategies'
+export { LazyTranslationProvider } from './LazyTranslationProvider'
+export type { LazyLoader, LazyTranslationProviderOptions } from './LazyTranslationProvider'
+export {
+  IncrementalDomainProvider,
+  isDomainAwareProvider,
+} from './IncrementalDomainProvider'
+export type {
+  DomainLoader,
+  IncrementalDomainProviderOptions,
+} from './IncrementalDomainProvider'
+export { createYamlLoader } from './loaders/yaml'
+export type { YamlTextImport } from './loaders/yaml'
+export { createDefaultCoreProvider } from './defaults/DefaultCoreProvider'
+export { useI18n, I18N_INJECTION_KEY } from './useI18n'
+export type {
+  AliasPattern,
+  CoreMessages,
+  EntityMessages,
+  I18nOptions,
+  KeyStrategy,
+  KeyStrategyName,
+  MessagesBundle,
+  MessagesNode,
+  NavMessages,
+  ResolveStep,
+  ResolveTrace,
+  TranslateParams,
+  TranslationProvider,
+} from './types'

package/src/i18n/loaders/raw-modules.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ambient declarations for Vite/Vitest `?raw` imports of arbitrary text
+ * files (YAML, etc.). Lets `import yamlText from './foo.yml?raw'` type-check
+ * without per-call casts.
+ */
+
+declare module '*.yml?raw' {
+  const content: string
+  export default content
+}
+
+declare module '*.yaml?raw' {
+  const content: string
+  export default content
+}

package/src/i18n/loaders/yaml.ts

@@ -0,0 +1,35 @@
+/**
+ * YAML loader factory for LazyTranslationProvider.
+ *
+ * Given a `locale → () => Promise<{ default: string }>` map, returns a
+ * `LazyLoader` that resolves the YAML text for the requested locale and
+ * parses it through the `yaml` package.
+ *
+ * Typical usage with Vite/Vitest `?raw` imports (qdadm-internal default):
+ *
+ *   const loader = createYamlLoader({
+ *     en: () => import('./core.en.yml?raw'),
+ *     fr: () => import('./core.fr.yml?raw'),
+ *   })
+ *
+ * The dynamic-import boundary is what gives us code-splitting: the YAML for
+ * a locale is only fetched + parsed when that locale is requested.
+ */
+
+import { parse as parseYaml } from 'yaml'
+
+import type { MessagesBundle } from '@quazardous/qdcore'
+import type { LazyLoader } from '../LazyTranslationProvider'
+
+export type YamlTextImport = () => Promise<{ default: string }>
+
+export function createYamlLoader(textImports: Record<string, YamlTextImport>): LazyLoader {
+  return async (locale: string) => {
+    const importer = textImports[locale]
+    if (!importer) return null
+    const mod = await importer()
+    const parsed = parseYaml(mod.default)
+    if (!parsed || typeof parsed !== 'object') return null
+    return parsed as MessagesBundle
+  }
+}

package/src/i18n/strategies.ts

@@ -0,0 +1,4 @@
+/**
+ * strategies — qdadm re-export from `@quazardous/qdcore/i18n`.
+ */
+export { STRATEGIES, resolveStrategy, defineStrategy } from '@quazardous/qdcore'

package/src/i18n/types.ts

@@ -0,0 +1,34 @@
+/**
+ * qdadm i18n types.
+ *
+ * Generic types come from `@quazardous/qdcore/i18n`; this module adds the
+ * admin-specific `I18nOptions` (kernel constructor option that toggles the
+ * default core admin bundles shipped via DefaultCoreProvider).
+ */
+
+import type { BaseI18nOptions } from '@quazardous/qdcore'
+
+export type {
+  AliasPattern,
+  BaseI18nOptions,
+  CoreMessages,
+  EntityMessages,
+  KeyStrategy,
+  KeyStrategyName,
+  MessagesBundle,
+  MessagesNode,
+  NavMessages,
+  ResolveStep,
+  ResolveTrace,
+  TranslateParams,
+  TranslationProvider,
+} from '@quazardous/qdcore'
+
+/**
+ * Kernel-level i18n options for qdadm. Extends the generic shared shape with
+ * admin-only knobs.
+ */
+export interface I18nOptions extends BaseI18nOptions {
+  /** Disable shipping qdadm's default core.* bundles (EN + FR). Default: false. */
+  disableDefaultCoreBundle?: boolean
+}

package/src/i18n/useI18n.ts

@@ -0,0 +1,34 @@
+/**
+ * useI18n - Vue composable for accessing the kernel I18n instance.
+ *
+ * Falls back to a no-op shim if no I18n has been provided to the app — useful
+ * for components rendered outside a kernel (tests, isolated examples).
+ */
+
+import { computed, inject, type Ref, type ComputedRef } from 'vue'
+import type { I18n } from './I18n'
+import type { TranslateParams } from './types'
+
+export const I18N_INJECTION_KEY = Symbol('qdadm.i18n')
+
+export interface UseI18nResult {
+  t: (key: string, params?: TranslateParams) => string
+  locale: ComputedRef<string> | Ref<string>
+  i18n: I18n | null
+}
+
+export function useI18n(): UseI18nResult {
+  const i18n = inject<I18n | null>(I18N_INJECTION_KEY, null)
+  if (!i18n) {
+    return {
+      t: (key: string) => key,
+      locale: computed(() => 'en'),
+      i18n: null,
+    }
+  }
+  return {
+    t: (key, params) => i18n.t(key, params),
+    locale: i18n.locale,
+    i18n,
+  }
+}

package/src/index.ts

@@ -410,6 +410,43 @@ export * from './notifications/index'
 //   import { debugBar, DebugModule } from 'qdadm/debug'
 // ════════════════════════════════════════════════════════════════════════════
 
+// ════════════════════════════════════════════════════════════════════════════
+// I18N (schema-derived keys, pluggable providers, signal-driven locale)
+// ════════════════════════════════════════════════════════════════════════════
+export {
+  I18n,
+  MessagesRegistry,
+  Resolver,
+  snakeCaseToTitle,
+  InlineTranslationProvider,
+  defineStrategy,
+  resolveStrategy,
+  STRATEGIES,
+  LazyTranslationProvider,
+  IncrementalDomainProvider,
+  isDomainAwareProvider,
+  createYamlLoader,
+  createDefaultCoreProvider,
+  useI18n,
+  I18N_INJECTION_KEY,
+} from './i18n'
+export type {
+  AliasPattern,
+  CoreMessages,
+  EntityMessages,
+  I18nDeps,
+  I18nOptions,
+  KeyStrategy,
+  KeyStrategyName,
+  MessagesBundle,
+  MessagesNode,
+  NavMessages,
+  ResolveStep,
+  ResolveTrace,
+  TranslateParams,
+  TranslationProvider,
+} from './i18n'
+
 // ════════════════════════════════════════════════════════════════════════════
 // ASSETS
 // ════════════════════════════════════════════════════════════════════════════

package/src/kernel/EventRouter.ts

@@ -1,306 +1,23 @@
 /**
- * EventRouter - Declarative signal routing
+ * EventRouter — qdadm re-export.
  *
- * Routes one signal to multiple targets (signals or callbacks).
- * Configured at Kernel level to keep components simple.
+ * The actual implementation now lives in `@quazardous/qdcore` so it can be
+ * shared with qdcms. The legacy `orchestrator` constructor option (which was
+ * never actually read by any callback in qdadm) has been dropped; callers
+ * needing extras in `RouteContext` should use the new `context` option:
  *
- * Usage:
- * ```js
- * const router = new EventRouter({
- *   signals,      // SignalBus instance
- *   orchestrator, // Orchestrator instance (optional, for callbacks)
- *   routes: {
- *     // Auth events → datalayer invalidation with actuator (only authSensitive entities react)
- *     'auth:**': [{ signal: 'entity:datalayer-invalidate', transform: () => ({ actuator: 'auth' }) }],
- *
- *     // Custom routing with transform
- *     'order:completed': [
- *       { signal: 'notify', transform: (p) => ({ msg: `Order ${p.id} done` }) },
- *       (payload, ctx) => { ... }  // callback
- *     ]
- *   }
- * })
+ * ```ts
+ * createEventRouter({ signals, context: { orchestrator }, routes })
+ * // -> available inside callbacks as ctx.orchestrator
  * ```
  */
 
-import type { SignalBus } from './SignalBus'
-import type { Orchestrator } from '../orchestrator/Orchestrator'
-
-/**
- * Route target with signal and optional transform
- */
-export interface SignalTarget {
-  signal: string
-  transform?: (payload: unknown) => unknown
-}
-
-/**
- * Route callback context
- */
-export interface RouteContext {
-  signals: SignalBus
-  orchestrator: Orchestrator | null
-}
-
-/**
- * Route callback function
- */
-export type RouteCallback = (payload: unknown, context: RouteContext) => void
-
-/**
- * Route target types
- */
-export type RouteTarget = string | SignalTarget | RouteCallback
-
-/**
- * Routes configuration
- */
-export type RoutesConfig = Record<string, RouteTarget[]>
-
-/**
- * EventRouter options
- */
-export interface EventRouterOptions {
-  signals: SignalBus
-  orchestrator?: Orchestrator | null
-  routes?: RoutesConfig
-  debug?: boolean
-}
-
-/**
- * Detect cycles in route graph using DFS
- */
-function detectCycles(routes: RoutesConfig): string[] | null {
-  // Build adjacency list (only signal targets, not callbacks)
-  const graph = new Map<string, string[]>()
-
-  for (const [source, targets] of Object.entries(routes)) {
-    const signalTargets: string[] = []
-    for (const target of targets) {
-      if (typeof target === 'string') {
-        signalTargets.push(target)
-      } else if (target && typeof target === 'object' && 'signal' in target) {
-        signalTargets.push(target.signal)
-      }
-      // Functions don't create edges in the graph
-    }
-    graph.set(source, signalTargets)
-  }
-
-  // DFS cycle detection
-  const visited = new Set<string>()
-  const recursionStack = new Set<string>()
-  const path: string[] = []
-
-  function dfs(node: string): string[] | null {
-    visited.add(node)
-    recursionStack.add(node)
-    path.push(node)
-
-    const neighbors = graph.get(node) || []
-    for (const neighbor of neighbors) {
-      if (!visited.has(neighbor)) {
-        const cycle = dfs(neighbor)
-        if (cycle) return cycle
-      } else if (recursionStack.has(neighbor)) {
-        // Found cycle - return path from neighbor to current
-        const cycleStart = path.indexOf(neighbor)
-        return [...path.slice(cycleStart), neighbor]
-      }
-    }
-
-    path.pop()
-    recursionStack.delete(node)
-    return null
-  }
-
-  // Check all nodes
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      const cycle = dfs(node)
-      if (cycle) return cycle
-    }
-  }
-
-  return null
-}
-
-export class EventRouter {
-  private _signals: SignalBus
-  private _orchestrator: Orchestrator | null
-  private _routes: RoutesConfig
-  private _debug: boolean
-  private _cleanups: Array<() => void> = []
-
-  constructor(options: EventRouterOptions) {
-    const { signals, orchestrator = null, routes = {}, debug = false } = options
-
-    if (!signals) {
-      throw new Error('[EventRouter] signals is required')
-    }
-
-    this._signals = signals
-    this._orchestrator = orchestrator
-    this._routes = routes
-    this._debug = debug
-
-    // Validate and setup
-    this._validateRoutes()
-    this._setupListeners()
-  }
-
-  /**
-   * Validate routes configuration and check for cycles
-   */
-  private _validateRoutes(): void {
-    // Check for cycles
-    const cycle = detectCycles(this._routes)
-    if (cycle) {
-      throw new Error(`[EventRouter] Cycle detected: ${cycle.join(' -> ')}`)
-    }
-
-    // Validate each route
-    for (const [source, targets] of Object.entries(this._routes)) {
-      if (!Array.isArray(targets)) {
-        throw new Error(
-          `[EventRouter] Route "${source}" must be an array of targets`
-        )
-      }
-
-      for (let i = 0; i < targets.length; i++) {
-        const target = targets[i]
-        const isString = typeof target === 'string'
-        const isFunction = typeof target === 'function'
-        const isObject =
-          target && typeof target === 'object' && 'signal' in target
-
-        if (!isString && !isFunction && !isObject) {
-          throw new Error(
-            `[EventRouter] Invalid target at "${source}"[${i}]: must be string, function, or { signal, transform? }`
-          )
-        }
-      }
-    }
-  }
-
-  /**
-   * Setup signal listeners for all routes
-   */
-  private _setupListeners(): void {
-    for (const [source, targets] of Object.entries(this._routes)) {
-      const cleanup = this._signals.on(source, (event: { data: unknown }) => {
-        this._handleRoute(source, event.data, targets)
-      })
-      this._cleanups.push(cleanup)
-    }
-
-    if (this._debug) {
-      console.debug(
-        `[EventRouter] Registered ${Object.keys(this._routes).length} routes`
-      )
-    }
-  }
-
-  /**
-   * Handle a routed signal
-   */
-  private _handleRoute(
-    source: string,
-    payload: unknown,
-    targets: RouteTarget[]
-  ): void {
-    if (this._debug) {
-      console.debug(`[EventRouter] ${source} -> ${targets.length} targets`)
-    }
-
-    const context: RouteContext = {
-      signals: this._signals,
-      orchestrator: this._orchestrator,
-    }
-
-    for (const target of targets) {
-      try {
-        if (typeof target === 'string') {
-          // String: emit signal with same payload
-          this._signals.emit(target, payload)
-          if (this._debug) {
-            console.debug(`[EventRouter]   -> ${target} (forward)`)
-          }
-        } else if (typeof target === 'function') {
-          // Function: call callback
-          target(payload, context)
-          if (this._debug) {
-            console.debug(`[EventRouter]   -> callback()`)
-          }
-        } else if (target && 'signal' in target) {
-          // Object: emit signal with transformed payload
-          const transformedPayload = target.transform
-            ? target.transform(payload)
-            : payload
-          this._signals.emit(target.signal, transformedPayload)
-          if (this._debug) {
-            console.debug(`[EventRouter]   -> ${target.signal} (transform)`)
-          }
-        }
-      } catch (error) {
-        console.error(
-          `[EventRouter] Error handling ${source} -> ${JSON.stringify(target)}:`,
-          error
-        )
-      }
-    }
-  }
-
-  /**
-   * Add a route dynamically
-   */
-  addRoute(source: string, targets: RouteTarget[]): void {
-    if (this._routes[source]) {
-      throw new Error(`[EventRouter] Route "${source}" already exists`)
-    }
-
-    // Validate new route doesn't create cycle
-    const testRoutes = { ...this._routes, [source]: targets }
-    const cycle = detectCycles(testRoutes)
-    if (cycle) {
-      throw new Error(
-        `[EventRouter] Adding route would create cycle: ${cycle.join(' -> ')}`
-      )
-    }
-
-    this._routes[source] = targets
-
-    // Setup listener
-    const cleanup = this._signals.on(source, (event: { data: unknown }) => {
-      this._handleRoute(source, event.data, targets)
-    })
-    this._cleanups.push(cleanup)
-  }
-
-  /**
-   * Get all registered routes
-   */
-  getRoutes(): RoutesConfig {
-    return { ...this._routes }
-  }
-
-  /**
-   * Dispose the router, cleaning up all listeners
-   */
-  dispose(): void {
-    for (const cleanup of this._cleanups) {
-      if (typeof cleanup === 'function') {
-        cleanup()
-      }
-    }
-    this._cleanups = []
-    this._routes = {}
-  }
-}
-
-/**
- * Factory function for creating EventRouter
- */
-export function createEventRouter(options: EventRouterOptions): EventRouter {
-  return new EventRouter(options)
-}
+export { EventRouter, createEventRouter } from '@quazardous/qdcore'
+export type {
+  SignalTarget,
+  RouteContext,
+  RouteCallback,
+  RouteTarget,
+  RoutesConfig,
+  EventRouterOptions,
+} from '@quazardous/qdcore'