@vertesia/fusion-ux 1.2.0 → 1.4.0-dev.20260614.160504Z

package/src/validation/fuzzyMatch.ts

@@ -7,31 +7,31 @@
  * Calculate Levenshtein distance between two strings
  */
 export function levenshteinDistance(a: string, b: string): number {
-  const matrix: number[][] = [];
-
-  // Initialize first column
-  for (let i = 0; i <= a.length; i++) {
-    matrix[i] = [i];
-  }
-
-  // Initialize first row
-  for (let j = 0; j <= b.length; j++) {
-    matrix[0][j] = j;
-  }
-
-  // Fill in the rest of the matrix
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,     // deletion
-        matrix[i][j - 1] + 1,     // insertion
-        matrix[i - 1][j - 1] + cost // substitution
-      );
+    const matrix: number[][] = [];
+
+    // Initialize first column
+    for (let i = 0; i <= a.length; i++) {
+        matrix[i] = [i];
+    }
+
+    // Initialize first row
+    for (let j = 0; j <= b.length; j++) {
+        matrix[0][j] = j;
     }
-  }
 
-  return matrix[a.length][b.length];
+    // Fill in the rest of the matrix
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(
+                matrix[i - 1][j] + 1, // deletion
+                matrix[i][j - 1] + 1, // insertion
+                matrix[i - 1][j - 1] + cost, // substitution
+            );
+        }
+    }
+
+    return matrix[a.length][b.length];
 }
 
 /**
@@ -41,44 +41,40 @@ export function levenshteinDistance(a: string, b: string): number {
  * @param maxDistance - Maximum edit distance to consider (default: 3)
  * @returns The closest key, or undefined if none are close enough
  */
-export function findClosestKey(
-  input: string,
-  validKeys: string[],
-  maxDistance: number = 3
-): string | undefined {
-  if (validKeys.length === 0) return undefined;
-
-  const inputLower = input.toLowerCase();
-  let bestMatch: string | undefined;
-  let bestDistance = Infinity;
-
-  for (const key of validKeys) {
-    const keyLower = key.toLowerCase();
-
-    // Exact case-insensitive match
-    if (inputLower === keyLower) {
-      return key;
-    }
-
-    // Check if input is a substring or key is a substring
-    if (inputLower.includes(keyLower) || keyLower.includes(inputLower)) {
-      const distance = Math.abs(inputLower.length - keyLower.length);
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        bestMatch = key;
-      }
-      continue;
-    }
-
-    // Levenshtein distance
-    const distance = levenshteinDistance(inputLower, keyLower);
-    if (distance < bestDistance && distance <= maxDistance) {
-      bestDistance = distance;
-      bestMatch = key;
+export function findClosestKey(input: string, validKeys: string[], maxDistance: number = 3): string | undefined {
+    if (validKeys.length === 0) return undefined;
+
+    const inputLower = input.toLowerCase();
+    let bestMatch: string | undefined;
+    let bestDistance = Infinity;
+
+    for (const key of validKeys) {
+        const keyLower = key.toLowerCase();
+
+        // Exact case-insensitive match
+        if (inputLower === keyLower) {
+            return key;
+        }
+
+        // Check if input is a substring or key is a substring
+        if (inputLower.includes(keyLower) || keyLower.includes(inputLower)) {
+            const distance = Math.abs(inputLower.length - keyLower.length);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestMatch = key;
+            }
+            continue;
+        }
+
+        // Levenshtein distance
+        const distance = levenshteinDistance(inputLower, keyLower);
+        if (distance < bestDistance && distance <= maxDistance) {
+            bestDistance = distance;
+            bestMatch = key;
+        }
     }
-  }
 
-  return bestMatch;
+    return bestMatch;
 }
 
 /**
@@ -88,22 +84,18 @@ export function findClosestKey(
  * @param maxResults - Maximum number of suggestions (default: 3)
  * @returns Array of similar keys
  */
-export function findSimilarKeys(
-  input: string,
-  validKeys: string[],
-  maxResults: number = 3
-): string[] {
-  if (validKeys.length === 0) return [];
-
-  const inputLower = input.toLowerCase();
-
-  const scored = validKeys
-    .map(key => ({
-      key,
-      distance: levenshteinDistance(inputLower, key.toLowerCase())
-    }))
-    .filter(({ distance }) => distance <= 4) // Filter out very different keys
-    .sort((a, b) => a.distance - b.distance);
-
-  return scored.slice(0, maxResults).map(({ key }) => key);
+export function findSimilarKeys(input: string, validKeys: string[], maxResults: number = 3): string[] {
+    if (validKeys.length === 0) return [];
+
+    const inputLower = input.toLowerCase();
+
+    const scored = validKeys
+        .map((key) => ({
+            key,
+            distance: levenshteinDistance(inputLower, key.toLowerCase()),
+        }))
+        .filter(({ distance }) => distance <= 4) // Filter out very different keys
+        .sort((a, b) => a.distance - b.distance);
+
+    return scored.slice(0, maxResults).map(({ key }) => key);
 }

package/src/validation/index.ts

@@ -2,7 +2,7 @@
  * Validation module exports
  */
 
-export { validateTemplate, parseAndValidateTemplate } from './validateTemplate.js';
-export { FragmentTemplateSchema, SectionTemplateSchema, FieldTemplateSchema } from './schemas.js';
+export { formatAvailableKeys, formatValidationErrors, formatValidationSuccess } from './formatErrors.js';
 export { findClosestKey, findSimilarKeys, levenshteinDistance } from './fuzzyMatch.js';
-export { formatValidationErrors, formatValidationSuccess, formatAvailableKeys } from './formatErrors.js';
+export { FieldTemplateSchema, FragmentTemplateSchema, SectionTemplateSchema } from './schemas.js';
+export { parseAndValidateTemplate, validateTemplate } from './validateTemplate.js';

package/src/validation/schemas.ts

@@ -3,90 +3,90 @@
  */
 
 import type { JSONSchemaType } from 'ajv';
-import type { FieldTemplate, SectionTemplate, FragmentTemplate, ColumnTemplate } from '../types.js';
+import type { ColumnTemplate, FieldTemplate, FragmentTemplate, SectionTemplate } from '../types.js';
 
 /**
  * Schema for field options (select dropdowns)
  */
 const FieldOptionSchema = {
-  type: 'object' as const,
-  properties: {
-    label: { type: 'string' as const },
-    value: { type: 'string' as const }
-  },
-  required: ['label', 'value'] as const,
-  additionalProperties: false
+    type: 'object' as const,
+    properties: {
+        label: { type: 'string' as const },
+        value: { type: 'string' as const },
+    },
+    required: ['label', 'value'] as const,
+    additionalProperties: false,
 };
 
 /**
  * Schema for a single field template
  */
 export const FieldTemplateSchema: JSONSchemaType<FieldTemplate> = {
-  type: 'object',
-  properties: {
-    label: { type: 'string' },
-    key: { type: 'string' },
-    format: {
-      type: 'string',
-      enum: ['text', 'number', 'currency', 'percent', 'date', 'boolean'],
-      nullable: true
-    },
-    unit: { type: 'string', nullable: true },
-    editable: { type: 'boolean', nullable: true },
-    inputType: {
-      type: 'string',
-      enum: ['text', 'number', 'date', 'select', 'checkbox'],
-      nullable: true
-    },
-    options: {
-      type: 'array',
-      items: FieldOptionSchema,
-      nullable: true
+    type: 'object',
+    properties: {
+        label: { type: 'string' },
+        key: { type: 'string' },
+        format: {
+            type: 'string',
+            enum: ['text', 'number', 'currency', 'percent', 'date', 'boolean'],
+            nullable: true,
+        },
+        unit: { type: 'string', nullable: true },
+        editable: { type: 'boolean', nullable: true },
+        inputType: {
+            type: 'string',
+            enum: ['text', 'number', 'date', 'select', 'checkbox'],
+            nullable: true,
+        },
+        options: {
+            type: 'array',
+            items: FieldOptionSchema,
+            nullable: true,
+        },
+        min: { type: 'number', nullable: true },
+        max: { type: 'number', nullable: true },
+        highlight: {
+            type: 'string',
+            enum: ['success', 'warning', 'error', 'info'],
+            nullable: true,
+        },
+        tooltip: { type: 'string', nullable: true },
+        decimals: { type: 'number', nullable: true },
+        currency: { type: 'string', nullable: true },
     },
-    min: { type: 'number', nullable: true },
-    max: { type: 'number', nullable: true },
-    highlight: {
-      type: 'string',
-      enum: ['success', 'warning', 'error', 'info'],
-      nullable: true
-    },
-    tooltip: { type: 'string', nullable: true },
-    decimals: { type: 'number', nullable: true },
-    currency: { type: 'string', nullable: true }
-  },
-  required: ['label', 'key'],
-  additionalProperties: false
+    required: ['label', 'key'],
+    additionalProperties: false,
 };
 
 /**
  * Schema for a table column template
  */
 export const ColumnTemplateSchema: JSONSchemaType<ColumnTemplate> = {
-  type: 'object',
-  properties: {
-    header: { type: 'string' },
-    key: { type: 'string' },
-    format: {
-      type: 'string',
-      enum: ['text', 'number', 'currency', 'percent', 'date', 'boolean'],
-      nullable: true
-    },
-    width: { type: 'string', nullable: true },
-    align: {
-      type: 'string',
-      enum: ['left', 'center', 'right'],
-      nullable: true
+    type: 'object',
+    properties: {
+        header: { type: 'string' },
+        key: { type: 'string' },
+        format: {
+            type: 'string',
+            enum: ['text', 'number', 'currency', 'percent', 'date', 'boolean'],
+            nullable: true,
+        },
+        width: { type: 'string', nullable: true },
+        align: {
+            type: 'string',
+            enum: ['left', 'center', 'right'],
+            nullable: true,
+        },
+        currency: { type: 'string', nullable: true },
+        decimals: { type: 'number', nullable: true },
+        highlight: {
+            type: 'string',
+            enum: ['success', 'warning', 'error', 'info'],
+            nullable: true,
+        },
     },
-    currency: { type: 'string', nullable: true },
-    decimals: { type: 'number', nullable: true },
-    highlight: {
-      type: 'string',
-      enum: ['success', 'warning', 'error', 'info'],
-      nullable: true
-    }
-  },
-  required: ['header', 'key'],
-  additionalProperties: false
+    required: ['header', 'key'],
+    additionalProperties: false,
 };
 
 /**
@@ -95,9 +95,9 @@ export const ColumnTemplateSchema: JSONSchemaType<ColumnTemplate> = {
  * Note: Using loose typing since VegaLiteSpec is intentionally flexible
  */
 export const VegaLiteSpecSchema = {
-  type: 'object' as const,
-  additionalProperties: true, // Allow any Vega-Lite properties
-  // We don't enforce specific properties since Vega-Lite has many valid forms
+    type: 'object' as const,
+    additionalProperties: true, // Allow any Vega-Lite properties
+    // We don't enforce specific properties since Vega-Lite has many valid forms
 };
 
 /**
@@ -105,17 +105,17 @@ export const VegaLiteSpecSchema = {
  * Note: Using loose typing for spec since VegaLiteSpec is flexible
  */
 export const ChartTemplateSchema = {
-  type: 'object' as const,
-  properties: {
-    title: { type: 'string' as const, nullable: true },
-    description: { type: 'string' as const, nullable: true },
-    spec: VegaLiteSpecSchema,
-    height: { type: 'number' as const, nullable: true },
-    width: { type: 'number' as const, nullable: true },
-    dataKey: { type: 'string' as const, nullable: true }
-  },
-  required: ['spec'] as const,
-  additionalProperties: false
+    type: 'object' as const,
+    properties: {
+        title: { type: 'string' as const, nullable: true },
+        description: { type: 'string' as const, nullable: true },
+        spec: VegaLiteSpecSchema,
+        height: { type: 'number' as const, nullable: true },
+        width: { type: 'number' as const, nullable: true },
+        dataKey: { type: 'string' as const, nullable: true },
+    },
+    required: ['spec'] as const,
+    additionalProperties: false,
 };
 
 /**
@@ -123,53 +123,53 @@ export const ChartTemplateSchema = {
  * Note: Using type assertion due to ChartTemplate's flexible VegaLiteSpec
  */
 export const SectionTemplateSchema = {
-  type: 'object',
-  properties: {
-    title: { type: 'string' },
-    layout: {
-      type: 'string',
-      enum: ['grid-2', 'grid-3', 'grid-4', 'list', 'table', 'chart'],
-      nullable: true
-    },
-    collapsed: { type: 'boolean', nullable: true },
-    fields: {
-      type: 'array',
-      items: FieldTemplateSchema,
-      nullable: true
+    type: 'object',
+    properties: {
+        title: { type: 'string' },
+        layout: {
+            type: 'string',
+            enum: ['grid-2', 'grid-3', 'grid-4', 'list', 'table', 'chart'],
+            nullable: true,
+        },
+        collapsed: { type: 'boolean', nullable: true },
+        fields: {
+            type: 'array',
+            items: FieldTemplateSchema,
+            nullable: true,
+        },
+        columns: {
+            type: 'array',
+            items: ColumnTemplateSchema,
+            nullable: true,
+        },
+        dataKey: { type: 'string', nullable: true },
+        chart: {
+            ...ChartTemplateSchema,
+            nullable: true,
+        },
     },
-    columns: {
-      type: 'array',
-      items: ColumnTemplateSchema,
-      nullable: true
-    },
-    dataKey: { type: 'string', nullable: true },
-    chart: {
-      ...ChartTemplateSchema,
-      nullable: true
-    }
-  },
-  required: ['title'],
-  additionalProperties: false
+    required: ['title'],
+    additionalProperties: false,
 } as JSONSchemaType<SectionTemplate>;
 
 /**
  * Schema for the root fragment template
  */
 export const FragmentTemplateSchema = {
-  type: 'object',
-  properties: {
-    title: { type: 'string', nullable: true },
-    entityType: {
-      type: 'string',
-      enum: ['fund', 'scenario', 'portfolio', 'transaction', 'custom'],
-      nullable: true
-    },
-    sections: {
-      type: 'array',
-      items: SectionTemplateSchema
+    type: 'object',
+    properties: {
+        title: { type: 'string', nullable: true },
+        entityType: {
+            type: 'string',
+            enum: ['fund', 'scenario', 'portfolio', 'transaction', 'custom'],
+            nullable: true,
+        },
+        sections: {
+            type: 'array',
+            items: SectionTemplateSchema,
+        },
+        footer: { type: 'string', nullable: true },
     },
-    footer: { type: 'string', nullable: true }
-  },
-  required: ['sections'],
-  additionalProperties: false
+    required: ['sections'],
+    additionalProperties: false,
 } as JSONSchemaType<FragmentTemplate>;