@quazardous/qdadm 1.20.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quazardous/qdadm",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",

package/src/components/editors/VanillaJsonEditor.vue

@@ -6,10 +6,17 @@
  *
  * Usage:
  * <VanillaJsonEditor v-model="jsonData" mode="tree" />
+ *
+ * Inline JSON Schema validation (errors highlighted live in the editor):
+ * <VanillaJsonEditor v-model="jsonData" :schema="mySchema" />
+ *
+ * Or a raw validator for advanced cases (takes precedence over `schema`):
+ * <VanillaJsonEditor v-model="jsonData" :validator="myValidator" />
  */
 
 import { ref, watch, onMounted, onUnmounted, nextTick } from 'vue'
 import { JSONEditor, type Content, type ContentErrors, type OnChangeStatus, type Mode } from 'vanilla-jsoneditor'
+import { buildJsonValidator, type Validator, type JSONSchema, type JsonValidatorOptions } from './jsonValidator'
 
 type JsonValue = Record<string, unknown> | unknown[] | string | null
 
@@ -21,6 +28,14 @@ interface Props {
   mainMenuBar?: boolean
   navigationBar?: boolean
   statusBar?: boolean
+  /** JSON Schema for inline Ajv validation (errors highlighted in the editor). */
+  schema?: JSONSchema
+  /** Raw validator function — takes precedence over `schema`. */
+  validator?: Validator
+  /** Optional `$ref` definitions passed through to the Ajv validator. */
+  schemaDefinitions?: JsonValidatorOptions['schemaDefinitions']
+  /** Optional Ajv options passed through to the Ajv validator. */
+  ajvOptions?: JsonValidatorOptions['ajvOptions']
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -30,9 +45,23 @@ const props = withDefaults(defineProps<Props>(), {
   readOnly: false,
   mainMenuBar: true,
   navigationBar: true,
-  statusBar: true
+  statusBar: true,
+  schema: undefined,
+  validator: undefined,
+  schemaDefinitions: undefined,
+  ajvOptions: undefined
 })
 
+// Resolve the effective validator from props (raw validator > schema > none).
+function resolveValidator(): Validator | undefined {
+  return buildJsonValidator({
+    validator: props.validator,
+    schema: props.schema,
+    schemaDefinitions: props.schemaDefinitions,
+    ajvOptions: props.ajvOptions
+  })
+}
+
 const emit = defineEmits<{
   'update:modelValue': [value: JsonValue]
   'change': [value: JsonValue]
@@ -76,6 +105,7 @@ onMounted(() => {
       mainMenuBar: props.mainMenuBar,
       navigationBar: props.navigationBar,
       statusBar: props.statusBar,
+      validator: resolveValidator(),
       onChange: (updatedContent: Content, _previousContent: Content, { contentErrors }: OnChangeStatus) => {
         // Skip if this change came from a programmatic prop update
         if (updatingFromProp.value) return
@@ -144,6 +174,17 @@ watch(() => props.readOnly, (newReadOnly: boolean) => {
   }
 })
 
+// Watch validator/schema changes — rebuild and re-apply so edits re-validate live
+watch(
+  () => [props.validator, props.schema, props.schemaDefinitions, props.ajvOptions],
+  () => {
+    if (editor) {
+      editor.updateProps({ validator: resolveValidator() })
+    }
+  },
+  { deep: true }
+)
+
 // Cleanup
 onUnmounted(() => {
   if (editor) {

package/src/components/editors/jsonValidator.ts

@@ -0,0 +1,44 @@
+/**
+ * jsonValidator - build a vanilla-jsoneditor `Validator` from wrapper props.
+ *
+ * Pure helper extracted from VanillaJsonEditor so the resolution logic
+ * (raw validator vs JSON Schema vs none) is unit-testable without mounting the
+ * Svelte editor. See qdadm #1050.
+ */
+import {
+  createAjvValidator,
+  type Validator,
+  type JSONSchema,
+  type AjvValidatorOptions,
+} from 'vanilla-jsoneditor'
+
+export type { Validator, JSONSchema }
+
+export interface JsonValidatorOptions {
+  /** Raw validator function — takes precedence over `schema` when both are set. */
+  validator?: Validator
+  /** JSON Schema; compiled to a validator via Ajv (bundled in vanilla-jsoneditor). */
+  schema?: JSONSchema
+  /** Optional `$ref` definitions passed through to `createAjvValidator`. */
+  schemaDefinitions?: AjvValidatorOptions['schemaDefinitions']
+  /** Optional Ajv options passed through to `createAjvValidator`. */
+  ajvOptions?: AjvValidatorOptions['ajvOptions']
+}
+
+/**
+ * Resolve the effective validator:
+ * - an explicit `validator` wins;
+ * - otherwise a `schema` is compiled with `createAjvValidator`;
+ * - otherwise `undefined` (no validation — the wrapper's default behavior).
+ */
+export function buildJsonValidator(options: JsonValidatorOptions): Validator | undefined {
+  if (options.validator) return options.validator
+  if (options.schema) {
+    return createAjvValidator({
+      schema: options.schema,
+      schemaDefinitions: options.schemaDefinitions,
+      ajvOptions: options.ajvOptions,
+    })
+  }
+  return undefined
+}

package/src/generated/managers/testManager.ts

@@ -1,46 +0,0 @@
-/**
- * TestManager - Auto-generated EntityManager
- *
- * Generated by qdadm/gen/generateManagers
- * DO NOT EDIT MANUALLY - Changes will be overwritten
- *
- * Entity: test
- * Endpoint: /test
- */
-
-import { EntityManager } from '@quazardous/qdadm'
-import type { EntityRecord } from '@quazardous/qdadm'
-import { ApiStorage } from '@quazardous/qdadm'
-
-export interface TestEntity extends EntityRecord {
-}
-
-/**
- * Schema definition for test
- */
-export const testSchema = {
-  name: "test",
-  endpoint: "/test",
-  fields: {}
-} as const
-
-/**
- * Storage options for test
- */
-const storageOptions = {
-  endpoint: "/test"
-}
-
-/**
- * TestManager instance
- *
- * Provides CRUD operations for test entity.
- */
-export const testManager = new EntityManager<TestEntity>({
-  ...{
-  name: "test",
-  idField: "id",
-  fields: {}
-},
-  storage: new ApiStorage<TestEntity>(storageOptions)
-})

package/src/i18n/I18n.ts

@@ -59,6 +59,7 @@ export class I18n {
   private _appAliases: AliasPattern[]
   private _entityToModule: Map<string, string> = new Map()
   private _signals: I18nDeps['signals']
+  private _emitMissing: boolean
   private _defaultLocale: string
   private _fallbackLocale: string
   private _loadedLocales: Set<string> = new Set()
@@ -76,6 +77,7 @@ export class I18n {
     this._strategyName = options.keyStrategy ?? 'global'
     this._appAliases = options.aliases ? [...options.aliases] : []
     this._signals = deps.signals ?? null
+    this._emitMissing = options.emitMissing ?? true
 
     this._registry = new MessagesRegistry()
     this.inline = new InlineTranslationProvider()
@@ -99,7 +101,7 @@ export class I18n {
       fallbackLocale: this._fallbackLocale,
       globalAliases: this._currentStrategyAliases(),
       onMissing: (key, locale) => {
-        this._signals?.emit('i18n:missing', { key, locale })
+        if (this._emitMissing) this._signals?.emit('i18n:missing', { key, locale })
       },
     })
 

package/src/i18n/__tests__/I18n.test.ts

@@ -105,6 +105,37 @@ describe('I18n — locale change', () => {
   })
 })
 
+describe('I18n — emitMissing flag', () => {
+  function makeSignals() {
+    const events: Array<{ signal: string; data: unknown }> = []
+    return {
+      events,
+      signals: {
+        emit: (signal: string, data: unknown) => {
+          events.push({ signal, data })
+        },
+        on: () => () => {},
+      },
+    }
+  }
+
+  it('emits i18n:missing on an unresolved key by default', async () => {
+    const { events, signals } = makeSignals()
+    const i18n = new I18n({ disableDefaultCoreBundle: true }, { signals })
+    await i18n.bootstrap()
+    i18n.t('totally.unknown.key')
+    expect(events.some((e) => e.signal === 'i18n:missing')).toBe(true)
+  })
+
+  it('does not emit i18n:missing when emitMissing is false', async () => {
+    const { events, signals } = makeSignals()
+    const i18n = new I18n({ disableDefaultCoreBundle: true, emitMissing: false }, { signals })
+    await i18n.bootstrap()
+    i18n.t('totally.unknown.key')
+    expect(events.some((e) => e.signal === 'i18n:missing')).toBe(false)
+  })
+})
+
 describe('I18n — providers', () => {
   it('loads from a custom TranslationProvider during bootstrap', async () => {
     const provider: TranslationProvider = {

package/src/i18n/types.ts

@@ -31,4 +31,12 @@ export type {
 export interface I18nOptions extends BaseI18nOptions {
   /** Disable shipping qdadm's default core.* bundles (EN + FR). Default: false. */
   disableDefaultCoreBundle?: boolean
+  /**
+   * Emit the `i18n:missing` debug signal when a key cannot be resolved.
+   * Default: `true`. Set to `false` to silence the missing-key stream (e.g. an
+   * untranslated app where every key would otherwise fire it) — the debug
+   * panel's "Missing" section then stays empty. No functional impact: nothing
+   * but the debug collector consumes this signal.
+   */
+  emitMissing?: boolean
 }