mgv-backoffice 1.28.0 → 1.30.0

package/src/index.ts

@@ -45,6 +45,9 @@ export { default as BaseSegmentedControl } from './components/BaseSegmentedContr
 export { default as BaseTable } from './components/BaseTable.vue'
 export { default as BaseSpecFields } from './components/BaseSpecFields.vue'
 export { default as BaseStatBreakdown } from './components/BaseStatBreakdown.vue'
+export { default as BaseFilterChip } from './components/BaseFilterChip.vue'
+export { default as BaseCredentialsForm } from './components/BaseCredentialsForm.vue'
+export type { CredentialsView, CredentialsUpdate } from './components/BaseCredentialsForm.vue'
 
 // Composables
 export { useTheme, initTheme } from './composables/useTheme'
@@ -58,6 +61,7 @@ export { useMobileSidebar } from './composables/useMobileSidebar'
 export { useSidebarCollapse } from './composables/useSidebarCollapse'
 export type { UseSidebarCollapseOptions } from './composables/useSidebarCollapse'
 export { useNotifications } from './composables/useNotifications'
+export { useQueryParamSync } from './composables/useQueryParamSync'
 
 // Enums
 export { AlertEnum } from './enums/AlertEnum'
@@ -96,11 +100,13 @@ export {
   fmtNumber,
   fmtDate,
   fmtDateTime,
+  fmtDateTimeMs,
   fmtDateShort,
   fmtPrice,
   fmtPct,
   fmtUsd,
   fmtDuration,
 } from './utils/format'
+export { buildSpecParams, firstInvalidNumericSpec } from './utils/specForm'
 export { computePnL } from './utils/pnl'
 export type { PnL, PnLInputs } from './utils/pnl'

package/src/types/specField.ts

@@ -11,6 +11,11 @@ export interface SpecField {
   key: string
   label: string
   type: SpecFieldType
+  /**
+   * Default value the form seeds the field with. `null` marks the field as
+   * OPTIONAL for `firstInvalidNumericSpec` (blank = "knob disabled").
+   */
+  default?: SpecFieldValue | null
   /** Choices for `type: 'select'`. */
   options?: string[] | null
   /** Step for numeric inputs; defaults to 1 (integer) / 0.01 (decimal). */

package/src/utils/format.test.ts

@@ -3,6 +3,7 @@ import {
   fmtNumber,
   fmtDate,
   fmtDateTime,
+  fmtDateTimeMs,
   fmtDateShort,
   fmtPrice,
   fmtPct,
@@ -10,6 +11,21 @@ import {
   fmtDuration,
 } from './format'
 
+describe('fmtDateTimeMs', () => {
+  it('keeps the millisecond fraction so same-second rows stay distinguishable', () => {
+    const out = fmtDateTimeMs('2026-06-08T14:30:51.123Z')
+    expect(out).toMatch(/51[.,:]?\d*123|123/) // ms fraction present, locale separators vary
+  })
+
+  it('accepts epoch millis', () => {
+    expect(fmtDateTimeMs(0)).toMatch(/19?70/)
+  })
+
+  it('falls back to the raw value for unparseable input', () => {
+    expect(fmtDateTimeMs('not-a-date')).toBe('Invalid Date')
+  })
+})
+
 const EM_DASH = '—'
 
 // Fraction digits are locale-stable even when the grouping/decimal

package/src/utils/format.ts

@@ -55,6 +55,29 @@ export function fmtDateShort(ms: number): string {
   return new Date(ms).toLocaleDateString(undefined, { month: 'short', day: 'numeric' })
 }
 
+/**
+ * Format an ISO string / epoch-millis as a full 24-hour locale date-time WITH
+ * the millisecond fraction — for dense feeds where several rows can land in
+ * the same second and must stay distinguishable. Falls back to the raw value
+ * when the input can't be parsed.
+ */
+export function fmtDateTimeMs(s: string | number): string {
+  try {
+    return new Date(s).toLocaleString(undefined, {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      fractionalSecondDigits: 3,
+      hour12: false,
+    })
+  } catch {
+    return String(s)
+  }
+}
+
 /**
  * Format a price with precision that scales to magnitude: penny stocks and
  * sub-cent crypto get more decimals so the value never collapses to "0.00".

package/src/utils/specForm.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest'
+import type { SpecField } from '../types/specField'
+import { buildSpecParams, firstInvalidNumericSpec } from './specForm'
+
+// Mirrors a typical backend catalogue shape: required numerics carry a
+// default, the optional field carries `default: null` (the optionality
+// convention — blank means "knob disabled").
+const specs: SpecField[] = [
+  { key: 'amountPerSymbol', label: 'Amount per symbol ($)', type: 'decimal', default: 4, min: 1, step: 0.01, options: null, help: '' },
+  { key: 'stopLossPercent', label: 'Stop loss (%)', type: 'decimal', default: null, min: 0.1, step: 0.1, options: null, help: '' },
+]
+
+describe('firstInvalidNumericSpec', () => {
+  it('flags a blank required numeric field', () => {
+    expect(firstInvalidNumericSpec(specs, { amountPerSymbol: '', stopLossPercent: 1 }))
+      .toBe('Amount per symbol ($)')
+  })
+
+  it.each([['' as const], [null as never], [undefined as never]])(
+    'accepts a blank optional field (cleared → %j)',
+    (blank) => {
+      expect(firstInvalidNumericSpec(specs, { amountPerSymbol: 10, stopLossPercent: blank }))
+        .toBeNull()
+    },
+  )
+
+  it('still validates a non-blank value on an optional field', () => {
+    expect(firstInvalidNumericSpec(specs, { amountPerSymbol: 10, stopLossPercent: NaN }))
+      .toBe('Stop loss (%)')
+    expect(firstInvalidNumericSpec(specs, { amountPerSymbol: 10, stopLossPercent: 2.5 }))
+      .toBeNull()
+  })
+
+  it('accepts a fully valid value set and tolerates missing specs', () => {
+    expect(firstInvalidNumericSpec(specs, { amountPerSymbol: 10, stopLossPercent: 1 })).toBeNull()
+    expect(firstInvalidNumericSpec(undefined, {})).toBeNull()
+  })
+})
+
+describe('buildSpecParams', () => {
+  it('seeds from defaults, keeping caller-supplied overlaps', () => {
+    expect(buildSpecParams(specs, { amountPerSymbol: 10 }).amountPerSymbol).toBe(10)
+    expect(buildSpecParams(specs, {}).amountPerSymbol).toBe(4)
+  })
+
+  it('seeds an optional field with null (renders as an empty input)', () => {
+    expect(buildSpecParams(specs, {}).stopLossPercent).toBeNull()
+  })
+
+  it('returns an empty map when there are no specs', () => {
+    expect(buildSpecParams(undefined, { anything: 1 })).toEqual({})
+  })
+})

package/src/utils/specForm.ts

@@ -0,0 +1,48 @@
+import type { SpecField, SpecFieldValue } from '../types/specField'
+
+/**
+ * Helpers for spec-driven forms (the value maps behind BaseSpecFields), so
+ * param seeding and numeric validation stay single-sourced across consumers.
+ */
+
+/**
+ * Build the value map for a spec set: keep any overlapping values the caller
+ * already has (e.g. a shared amount field carries across spec sets), otherwise
+ * fall back to the spec's default. No specs → empty map. A `default: null`
+ * seeds the field with null so it renders as an empty (optional) input.
+ */
+export function buildSpecParams(
+  specs: readonly SpecField[] | undefined,
+  existing: Record<string, SpecFieldValue>,
+): Record<string, SpecFieldValue> {
+  const out: Record<string, SpecFieldValue> = {}
+  if (!specs) return out
+  for (const spec of specs) {
+    const prev = existing[spec.key]
+    out[spec.key] = prev !== undefined && prev !== null ? prev : (spec.default as SpecFieldValue)
+  }
+  return out
+}
+
+/**
+ * Label of the first blank / NaN numeric field (a cleared number input becomes
+ * '' under number coercion), or null when every numeric field holds a number.
+ * A spec whose `default` is null is OPTIONAL: blank means "knob disabled" and
+ * must pass; a non-blank value on an optional field is still validated as a
+ * number.
+ */
+export function firstInvalidNumericSpec(
+  specs: readonly SpecField[] | undefined,
+  params: Record<string, SpecFieldValue>,
+): string | null {
+  if (!specs) return null
+  for (const spec of specs) {
+    if (spec.type === 'decimal' || spec.type === 'integer') {
+      const v = params[spec.key]
+      const blank = v === '' || v === null || v === undefined
+      if (spec.default === null && blank) continue
+      if (typeof v !== 'number' || Number.isNaN(v)) return spec.label
+    }
+  }
+  return null
+}