@quazardous/qdadm 2.12.0 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quazardous/qdadm",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",
@@ -71,6 +71,9 @@
     },
     "vite": {
       "optional": true
+    },
+    "primevue": {
+      "optional": true
     }
   },
   "optionalDependencies": {

package/src/composables/useDirtyState.ts

@@ -59,6 +59,10 @@ export function useDirtyState<T extends FormState = FormState>(
   // initial side each time doubled the per-key work, and the old
   // JSON.parse(JSON.stringify(state)) deep clone tripled the snapshot cost.
   let initialFieldSnapshots: Map<string, string> | null = null
+  // Parsed deep copy of the initial form, kept for path-aware isFieldDirty
+  // (#1396). Built once per snapshot; the per-keystroke checkDirty path
+  // (#1194) never touches it.
+  let initialForm: Record<string, unknown> | null = null
   const ready = ref(false)
 
   /** Resolve the form object inside the state (common 'form'/'formData' patterns). */
@@ -76,6 +80,16 @@ export function useDirtyState<T extends FormState = FormState>(
     return s === undefined ? 'undefined' : s
   }
 
+  /** Resolve a dot path ('config.login') in an object, undefined-safe. */
+  function getByPath(obj: unknown, path: string): unknown {
+    let cur: unknown = obj
+    for (const seg of path.split('.')) {
+      if (cur === null || cur === undefined || typeof cur !== 'object') return undefined
+      cur = (cur as Record<string, unknown>)[seg]
+    }
+    return cur
+  }
+
   function getFormSnapshot(): string {
     return JSON.stringify(getState())
   }
@@ -96,6 +110,7 @@ export function useDirtyState<T extends FormState = FormState>(
         fieldSnapshots.set(key, stringifyField(form[key]))
       }
       initialFieldSnapshots = fieldSnapshots
+      initialForm = JSON.parse(JSON.stringify(form)) as Record<string, unknown>
       ready.value = true
     })
   }
@@ -126,7 +141,21 @@ export function useDirtyState<T extends FormState = FormState>(
   }
 
   function isFieldDirty(fieldName: string): boolean {
-    return dirtyFields.value.includes(fieldName)
+    // Dot-free names: exact historical behavior.
+    if (!fieldName.includes('.')) {
+      return dirtyFields.value.includes(fieldName)
+    }
+    // Path-aware (#1396): a sub-field can only be dirty if its ROOT key is —
+    // the pre-filter reuses the per-key work checkDirty already did, and
+    // reading dirtyFields keeps the same reactive trigger as flat names.
+    const root = fieldName.slice(0, fieldName.indexOf('.'))
+    if (!dirtyFields.value.includes(root)) return false
+    if (!initialForm) return false
+    const currentForm = resolveForm(getState())
+    return (
+      stringifyField(getByPath(currentForm, fieldName)) !==
+      stringifyField(getByPath(initialForm, fieldName))
+    )
   }
 
   function reset(): void {
@@ -134,6 +163,7 @@ export function useDirtyState<T extends FormState = FormState>(
     dirtyFields.value = []
     initialSnapshot.value = null
     initialFieldSnapshots = null
+    initialForm = null
     ready.value = false
   }
 

package/src/vite/qdadmPlugin.ts

@@ -53,6 +53,26 @@ export interface QdadmVitePluginOptions {
    * (vue, vue-router, primevue, pinia).
    */
   dedupe?: string[]
+  /**
+   * PrimeVue "flavor" (#1393): alias every `primevue/*` import to a
+   * compatible fork (e.g. OpenVue). qdadm officially maintains and tests
+   * `primevue@4` (MIT) only — a flavor keeping the v4 module layout/API is
+   * drop-in; divergences are the consumer's to absorb.
+   *
+   * ```ts
+   * qdadmVitePlugin({ primevue: { package: 'openvue' } })
+   * ```
+   */
+  primevue?: {
+    /** Package that replaces `primevue` (e.g. 'openvue'). */
+    package: string
+    /**
+     * Optional package replacing `@primeuix/themes` — only needed if the
+     * flavor ships its own themes fork (none does today; OpenVue keeps the
+     * MIT @primeuix/* versions).
+     */
+    themes?: string
+  }
 }
 
 export function qdadmVitePlugin(options: QdadmVitePluginOptions = {}): Plugin {
@@ -76,12 +96,33 @@ export function qdadmVitePlugin(options: QdadmVitePluginOptions = {}): Plugin {
         // not installed under root node_modules (aliased/hoisted) — nothing to allow
       }
 
+      // Flavor aliasing (#1393): after the alias, no `primevue`/themes ids
+      // remain in the graph — dedupe/exclude lists must name the flavor.
+      const flavor = options.primevue ?? null
+      const widgetPkg = flavor?.package ?? 'primevue'
+      const themesPkg = flavor?.themes ?? '@primeuix/themes'
+      const alias = []
+      if (flavor) {
+        alias.push({ find: /^primevue(\/|$)/, replacement: `${flavor.package}$1` })
+        if (flavor.themes) {
+          alias.push({ find: /^@primeuix\/themes(\/|$)/, replacement: `${flavor.themes}$1` })
+        }
+      }
+
+      // With a flavor, the original packages may still be installed — keep
+      // them excluded too, or the optimizer pre-bundles a stray
+      // `primevue/*` id that bypassed the alias (split-instance again).
+      const widgetExcludes = flavor ? [widgetPkg, 'primevue'] : [widgetPkg]
+      const themesExcludes =
+        flavor?.themes ? [themesPkg, '@primeuix/themes'] : [themesPkg]
+
       return {
         resolve: {
-          dedupe: ['vue', 'vue-router', 'primevue', 'pinia', ...(options.dedupe ?? [])],
+          ...(alias.length > 0 ? { alias } : {}),
+          dedupe: ['vue', 'vue-router', widgetPkg, 'pinia', ...(options.dedupe ?? [])],
         },
         optimizeDeps: {
-          exclude: ['primevue', '@primeuix/themes', '@quazardous/qdadm'],
+          exclude: [...widgetExcludes, ...themesExcludes, '@quazardous/qdadm'],
           // One form per install mode: the nested path resolves through a
           // real node_modules chain (npm installs), the plain form through a
           // symlink realpath — declaring the unused one logs a "Failed to