qdadm 0.15.1 → 0.17.0

package/src/composables/useStatus.js

@@ -1,146 +0,0 @@
-/**
- * useStatus - Generic status composable
- *
- * Loads and formats status options from any API endpoint.
- * Provides caching, label/severity lookup helpers.
- *
- * Usage:
- * const { options, loadOptions, getLabel, getSeverity } = useStatus({
- *   endpoint: '/reference/queue-statuses',
- *   labelField: 'label',
- *   valueField: 'value',
- *   severityField: 'severity'
- * })
- */
-
-import { ref, inject } from 'vue'
-
-// Global cache for status options (keyed by endpoint)
-const statusCache = new Map()
-
-export function useStatus(config = {}) {
-  const {
-    endpoint,
-    labelField = 'label',
-    valueField = 'value',
-    severityField = 'severity',
-    // Optional: static options instead of API fetch
-    staticOptions = null,
-    // Optional: custom severity mapping function
-    severityMapper = null,
-    // Optional: default severity if not found
-    defaultSeverity = 'secondary'
-  } = config
-
-  const api = inject('apiAdapter')
-  const options = ref([])
-  const loading = ref(false)
-  const error = ref(null)
-
-  /**
-   * Load options from API or use static options
-   */
-  async function loadOptions(force = false) {
-    // Use static options if provided
-    if (staticOptions) {
-      options.value = staticOptions
-      return options.value
-    }
-
-    if (!endpoint) {
-      console.warn('[useStatus] No endpoint provided')
-      return []
-    }
-
-    // Check cache first (unless force refresh)
-    if (!force && statusCache.has(endpoint)) {
-      options.value = statusCache.get(endpoint)
-      return options.value
-    }
-
-    if (!api) {
-      console.warn('[useStatus] apiAdapter not provided')
-      return []
-    }
-
-    loading.value = true
-    error.value = null
-
-    try {
-      const response = await api.request('GET', endpoint)
-      // Handle both array response and { items: [] } response
-      const items = Array.isArray(response) ? response : (response?.items || response?.data || [])
-      options.value = items
-      statusCache.set(endpoint, items)
-      return items
-    } catch (e) {
-      error.value = e.message
-      console.error(`[useStatus] Failed to load options from ${endpoint}:`, e)
-      return []
-    } finally {
-      loading.value = false
-    }
-  }
-
-  /**
-   * Get label for a status value
-   */
-  function getLabel(value) {
-    if (value == null) return ''
-    const option = options.value.find(opt =>
-      (typeof opt === 'string' ? opt : opt[valueField]) === value
-    )
-    if (!option) return String(value)
-    return typeof option === 'string' ? option : option[labelField]
-  }
-
-  /**
-   * Get severity for a status value (for Tag/Badge color)
-   */
-  function getSeverity(value) {
-    if (value == null) return defaultSeverity
-
-    // Use custom mapper if provided
-    if (severityMapper) {
-      return severityMapper(value) || defaultSeverity
-    }
-
-    const option = options.value.find(opt =>
-      (typeof opt === 'string' ? opt : opt[valueField]) === value
-    )
-    if (!option || typeof option === 'string') return defaultSeverity
-    return option[severityField] || defaultSeverity
-  }
-
-  /**
-   * Get full option object for a value
-   */
-  function getOption(value) {
-    if (value == null) return null
-    return options.value.find(opt =>
-      (typeof opt === 'string' ? opt : opt[valueField]) === value
-    )
-  }
-
-  /**
-   * Clear cache for this endpoint or all endpoints
-   */
-  function clearCache(all = false) {
-    if (all) {
-      statusCache.clear()
-    } else if (endpoint) {
-      statusCache.delete(endpoint)
-    }
-  }
-
-  return {
-    options,
-    loading,
-    error,
-    loadOptions,
-    getLabel,
-    getSeverity,
-    getOption,
-    clearCache
-  }
-}

package/src/composables/useSubEditor.js

@@ -1,165 +0,0 @@
-import { computed, inject } from 'vue'
-
-/**
- * Composable for building sub-editor components that edit a portion of parent form data.
- *
- * Sub-editors receive data via v-model and emit updates, but don't handle persistence.
- * The parent form (using useForm/useBareForm) handles loading, saving, and dirty tracking.
- *
- * Usage in sub-editor:
- *   const props = defineProps({ modelValue: Object })
- *   const emit = defineEmits(['update:modelValue'])
- *
- *   const { data, update, field } = useSubEditor(props, emit)
- *
- *   // Access data
- *   data.value.someField
- *
- *   // Update single field
- *   update('someField', newValue)
- *
- *   // Computed getter/setter for field
- *   const myField = field('someField', defaultValue)
- *   myField.value = 'new value' // auto-emits update
- *
- *   // Nested field access
- *   const nested = field('config.subsection.value', 0)
- *
- * Features:
- * - Simplified update pattern (no manual spread)
- * - Computed fields with get/set for v-model binding
- * - Nested path support (dot notation)
- * - Default values
- * - Optional dirty field indicator integration with parent
- *
- * @param {Object} props - Component props (must include modelValue)
- * @param {Function} emit - Component emit function
- * @param {Object} options - Additional options
- * @param {*} options.defaultData - Default data structure if modelValue is empty
- */
-export function useSubEditor(props, emit, options = {}) {
-  const { defaultData = {} } = options
-
-  // Computed reference to data (with default fallback)
-  const data = computed(() => props.modelValue ?? defaultData)
-
-  /**
-   * Get value at nested path
-   */
-  function getNestedValue(obj, path) {
-    if (!path.includes('.')) {
-      return obj?.[path]
-    }
-    return path.split('.').reduce((curr, key) => curr?.[key], obj)
-  }
-
-  /**
-   * Set value at nested path, returning new object
-   */
-  function setNestedValue(obj, path, value) {
-    if (!path.includes('.')) {
-      return { ...obj, [path]: value }
-    }
-
-    const keys = path.split('.')
-    const result = { ...obj }
-    let current = result
-
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i]
-      current[key] = { ...current[key] }
-      current = current[key]
-    }
-
-    current[keys[keys.length - 1]] = value
-    return result
-  }
-
-  /**
-   * Update a field and emit the new value
-   * @param {string} path - Field path (supports dot notation for nested)
-   * @param {*} value - New value
-   */
-  function update(path, value) {
-    const newData = setNestedValue(data.value, path, value)
-    emit('update:modelValue', newData)
-  }
-
-  /**
-   * Replace entire data object
-   * @param {Object} newData - Complete new data object
-   */
-  function replace(newData) {
-    emit('update:modelValue', newData)
-  }
-
-  /**
-   * Create a computed ref for a field with get/set
-   * Useful for v-model binding in template
-   *
-   * @param {string} path - Field path (supports dot notation)
-   * @param {*} defaultValue - Default value if field is undefined
-   * @returns {ComputedRef} Writable computed ref
-   */
-  function field(path, defaultValue = undefined) {
-    return computed({
-      get: () => {
-        const value = getNestedValue(data.value, path)
-        return value !== undefined ? value : defaultValue
-      },
-      set: (value) => update(path, value)
-    })
-  }
-
-  /**
-   * Create multiple field refs at once
-   * @param {Object} fields - { fieldName: defaultValue, ... }
-   * @returns {Object} { fieldName: computedRef, ... }
-   */
-  function fields(fieldDefs) {
-    const result = {}
-    for (const [path, defaultValue] of Object.entries(fieldDefs)) {
-      result[path] = field(path, defaultValue)
-    }
-    return result
-  }
-
-  /**
-   * Get value with default fallback (non-reactive, for one-time reads)
-   */
-  function get(path, defaultValue = undefined) {
-    const value = getNestedValue(data.value, path)
-    return value !== undefined ? value : defaultValue
-  }
-
-  // Try to inject field-level dirty tracking from parent (if available)
-  const parentIsFieldDirty = inject('isFieldDirty', null)
-
-  /**
-   * Check if a field is dirty (if parent provides tracking)
-   * This allows sub-editors to show field-level dirty indicators
-   */
-  function isFieldDirty(path) {
-    if (!parentIsFieldDirty) return false
-    // The parent tracks 'form.value.fieldName' or similar
-    // We need to prefix with the path the parent uses
-    return parentIsFieldDirty(path)
-  }
-
-  return {
-    // Data access
-    data,
-    get,
-
-    // Updates
-    update,
-    replace,
-
-    // Field helpers
-    field,
-    fields,
-
-    // Dirty tracking (from parent)
-    isFieldDirty
-  }
-}

package/src/composables/useTabSync.js

@@ -1,110 +0,0 @@
-/**
- * useTabSync - Composable for tab navigation with URL hash sync
- *
- * Provides:
- * - activeTab computed from URL hash
- * - onTabChange handler to update URL
- * - Support for conditional tabs (edit mode only)
- * - Lazy loading trigger on tab activation
- *
- * Usage:
- *   const { activeTab, onTabChange } = useTabSync({
- *     validTabs: ['general', 'style', 'behavior', 'newsrooms'],
- *     defaultTab: 'general',
- *     restrictedTabs: { newsrooms: () => isEdit.value },
- *     onTabActivate: { newsrooms: () => loadNewsroomData() }
- *   })
- */
-
-import { computed } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-
-/**
- * @param {Object} options
- * @param {string[]} options.validTabs - List of valid tab values
- * @param {string} [options.defaultTab='general'] - Default tab when hash is invalid
- * @param {Object.<string, Function>} [options.restrictedTabs={}] - Tab name -> condition function
- * @param {Object.<string, Function>} [options.onTabActivate={}] - Tab name -> callback on first activation
- */
-export function useTabSync(options = {}) {
-  const {
-    validTabs = ['general'],
-    defaultTab = 'general',
-    restrictedTabs = {},
-    onTabActivate = {}
-  } = options
-
-  const route = useRoute()
-  const router = useRouter()
-
-  // Track which tabs have been activated (for lazy loading)
-  const activatedTabs = new Set([defaultTab])
-
-  /**
-   * Active tab derived from URL hash
-   */
-  const activeTab = computed(() => {
-    const hash = route.hash?.replace('#', '')
-
-    if (hash && validTabs.includes(hash)) {
-      // Check if tab is restricted
-      const restriction = restrictedTabs[hash]
-      if (restriction && !restriction()) {
-        return defaultTab
-      }
-      return hash
-    }
-
-    return defaultTab
-  })
-
-  /**
-   * Handle tab change - update URL hash and trigger callbacks
-   * @param {string} newTab
-   */
-  function onTabChange(newTab) {
-    // Update URL hash
-    router.replace({ ...route, hash: `#${newTab}` })
-
-    // Trigger lazy load callback if first activation
-    if (!activatedTabs.has(newTab)) {
-      activatedTabs.add(newTab)
-      const callback = onTabActivate[newTab]
-      if (callback) {
-        callback()
-      }
-    }
-  }
-
-  /**
-   * Check if a tab should be visible
-   * @param {string} tabName
-   * @returns {boolean}
-   */
-  function isTabVisible(tabName) {
-    const restriction = restrictedTabs[tabName]
-    if (restriction) {
-      return restriction()
-    }
-    return true
-  }
-
-  /**
-   * Navigate to a specific tab programmatically
-   * @param {string} tabName
-   */
-  function goToTab(tabName) {
-    if (validTabs.includes(tabName) && isTabVisible(tabName)) {
-      onTabChange(tabName)
-    }
-  }
-
-  return {
-    activeTab,
-    onTabChange,
-    isTabVisible,
-    goToTab
-  }
-}
-
-export default useTabSync