mgv-backoffice 1.29.0 → 1.30.0

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
+}