@flowuent-org/diagramming-core 1.3.10 → 1.4.1

package/packages/diagrams/src/lib/utils/configLoader.ts

@@ -1,329 +1,329 @@
-import { ValidationSchema, ValidationConfig } from '../types/validation-types';
-
-export interface ConfigSource {
-  type: 'local' | 'remote' | 'inline';
-  path?: string;
-  url?: string;
-  data?: ValidationSchema;
-}
-
-export interface ConfigLoaderOptions {
-  fallbackToDefault?: boolean;
-  cacheEnabled?: boolean;
-  cacheTimeout?: number;
-  retryAttempts?: number;
-  retryDelay?: number;
-}
-
-export class ConfigLoader {
-  private cache: Map<string, { data: ValidationSchema; timestamp: number }> =
-    new Map();
-  private defaultOptions: ConfigLoaderOptions = {
-    fallbackToDefault: true,
-    cacheEnabled: true,
-    cacheTimeout: 5 * 60 * 1000, // 5 minutes
-    retryAttempts: 3,
-    retryDelay: 1000, // 1 second
-  };
-
-  constructor(options?: Partial<ConfigLoaderOptions>) {
-    this.defaultOptions = { ...this.defaultOptions, ...options };
-  }
-
-  /**
-   * Load validation schema from a configuration source
-   */
-  async loadValidationSchema(
-    source: ConfigSource,
-    options?: Partial<ConfigLoaderOptions>,
-  ): Promise<ValidationSchema> {
-    const opts = { ...this.defaultOptions, ...options };
-    const cacheKey = this.getCacheKey(source);
-
-    // Check cache first
-    if (opts.cacheEnabled && this.cache.has(cacheKey)) {
-      const cached = this.cache.get(cacheKey)!;
-      if (Date.now() - cached.timestamp < opts.cacheTimeout!) {
-        return cached.data;
-      }
-      this.cache.delete(cacheKey);
-    }
-
-    try {
-      let schema: ValidationSchema;
-
-      switch (source.type) {
-        case 'local':
-          schema = await this.loadLocalSchema(source.path!);
-          break;
-        case 'remote':
-          schema = await this.loadRemoteSchema(source.url!, opts);
-          break;
-        case 'inline':
-          schema = source.data!;
-          break;
-        default:
-          throw new Error(`Unknown config source type: ${source.type}`);
-      }
-
-      // Cache the result
-      if (opts.cacheEnabled) {
-        this.cache.set(cacheKey, { data: schema, timestamp: Date.now() });
-      }
-
-      return schema;
-    } catch (error) {
-      console.warn(
-        `Failed to load validation schema from ${source.type}:`,
-        error,
-      );
-
-      if (opts.fallbackToDefault) {
-        return this.getDefaultSchema();
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Load schema from local file
-   */
-  private async loadLocalSchema(path: string): Promise<ValidationSchema> {
-    try {
-      // For local files, we'll use dynamic imports
-      const module = await import(path);
-      return module.default || module;
-    } catch (error) {
-      throw new Error(`Failed to load local schema from ${path}: ${error}`);
-    }
-  }
-
-  /**
-   * Load schema from remote URL
-   */
-  private async loadRemoteSchema(
-    url: string,
-    options: ConfigLoaderOptions,
-  ): Promise<ValidationSchema> {
-    let lastError: Error;
-
-    for (let attempt = 1; attempt <= options.retryAttempts!; attempt++) {
-      try {
-        const response = await fetch(url, {
-          method: 'GET',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-
-        const data = await response.json();
-        return this.validateSchemaStructure(data);
-      } catch (error) {
-        lastError = error as Error;
-
-        if (attempt < options.retryAttempts!) {
-          await this.delay(options.retryDelay!);
-        }
-      }
-    }
-
-    throw new Error(
-      `Failed to load remote schema after ${options.retryAttempts} attempts: ${lastError!.message}`,
-    );
-  }
-
-  /**
-   * Validate that the loaded data has the correct schema structure
-   */
-  private validateSchemaStructure(data: any): ValidationSchema {
-    // Basic validation - in production, you might want to use a schema validation library
-    if (!data || typeof data !== 'object') {
-      throw new Error('Invalid schema: data is not an object');
-    }
-
-    if (!data.version || !data.globalSettings || !data.dataTypes) {
-      throw new Error(
-        'Invalid schema: missing required fields (version, globalSettings, dataTypes)',
-      );
-    }
-
-    return data as ValidationSchema;
-  }
-
-  /**
-   * Get cache key for a source
-   */
-  private getCacheKey(source: ConfigSource): string {
-    switch (source.type) {
-      case 'local':
-        return `local:${source.path}`;
-      case 'remote':
-        return `remote:${source.url}`;
-      case 'inline':
-        return `inline:${Date.now()}`;
-      default:
-        return `unknown:${JSON.stringify(source)}`;
-    }
-  }
-
-  /**
-   * Delay execution for specified milliseconds
-   */
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Get default validation schema
-   */
-  private getDefaultSchema(): ValidationSchema {
-    return {
-      version: '1.0.0',
-      description: 'Default validation schema',
-      globalSettings: {
-        defaultSeverity: 'error',
-        showWarnings: true,
-        strictMode: false,
-      },
-      dataTypes: {
-        String: {
-          validation: {
-            required: {
-              enabled: true,
-              message: 'Value cannot be empty',
-              severity: 'error',
-            },
-          },
-        },
-        Number: {
-          validation: {
-            required: {
-              enabled: true,
-              message: 'Value cannot be empty',
-              severity: 'error',
-            },
-            numeric: {
-              enabled: true,
-              message: 'Value must be a valid number',
-              severity: 'error',
-            },
-          },
-        },
-        Boolean: {
-          validation: {
-            required: {
-              enabled: true,
-              message: 'Value cannot be empty',
-              severity: 'error',
-            },
-            boolean: {
-              enabled: true,
-              message: 'Value must be a valid boolean',
-              severity: 'error',
-            },
-          },
-        },
-      },
-      expressions: {
-        primitive: {
-          validation: {
-            required: {
-              enabled: true,
-              message: 'Value cannot be empty',
-              severity: 'error',
-            },
-          },
-        },
-        operation: {
-          validation: {
-            operands: {
-              required: {
-                enabled: true,
-                message: 'Operand {index} cannot be empty',
-                severity: 'error',
-              },
-            },
-          },
-        },
-      },
-      nodeTypes: {},
-      identifiers: {
-        validation: {
-          required: {
-            enabled: true,
-            message: 'Identifier cannot be empty',
-            severity: 'error',
-          },
-          format: {
-            enabled: true,
-            message: 'Invalid identifier format',
-            severity: 'error',
-          },
-        },
-      },
-      messages: {
-        custom: {
-          emptyValue: 'This field cannot be empty',
-          invalidFormat: 'Invalid format for this field',
-          typeMismatch: 'Value type does not match expected type',
-          validationFailed: 'Validation failed for this field',
-        },
-      },
-    };
-  }
-
-  /**
-   * Clear the configuration cache
-   */
-  clearCache(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getCacheStats(): {
-    size: number;
-    entries: Array<{ key: string; age: number }>;
-  } {
-    const now = Date.now();
-    const entries = Array.from(this.cache.entries()).map(([key, value]) => ({
-      key,
-      age: now - value.timestamp,
-    }));
-
-    return {
-      size: this.cache.size,
-      entries,
-    };
-  }
-}
-
-// Export singleton instance
-export const configLoader = new ConfigLoader();
-
-// Export convenience functions
-export const loadValidationSchema = (
-  source: ConfigSource,
-  options?: Partial<ConfigLoaderOptions>,
-) => configLoader.loadValidationSchema(source, options);
-
-export const loadLocalValidationSchema = (
-  path: string,
-  options?: Partial<ConfigLoaderOptions>,
-) => configLoader.loadValidationSchema({ type: 'local', path }, options);
-
-export const loadRemoteValidationSchema = (
-  url: string,
-  options?: Partial<ConfigLoaderOptions>,
-) => configLoader.loadValidationSchema({ type: 'remote', url }, options);
-
-export const loadInlineValidationSchema = (
-  data: ValidationSchema,
-  options?: Partial<ConfigLoaderOptions>,
-) => configLoader.loadValidationSchema({ type: 'inline', data }, options);
+import { ValidationSchema, ValidationConfig } from '../types/validation-types';
+
+export interface ConfigSource {
+  type: 'local' | 'remote' | 'inline';
+  path?: string;
+  url?: string;
+  data?: ValidationSchema;
+}
+
+export interface ConfigLoaderOptions {
+  fallbackToDefault?: boolean;
+  cacheEnabled?: boolean;
+  cacheTimeout?: number;
+  retryAttempts?: number;
+  retryDelay?: number;
+}
+
+export class ConfigLoader {
+  private cache: Map<string, { data: ValidationSchema; timestamp: number }> =
+    new Map();
+  private defaultOptions: ConfigLoaderOptions = {
+    fallbackToDefault: true,
+    cacheEnabled: true,
+    cacheTimeout: 5 * 60 * 1000, // 5 minutes
+    retryAttempts: 3,
+    retryDelay: 1000, // 1 second
+  };
+
+  constructor(options?: Partial<ConfigLoaderOptions>) {
+    this.defaultOptions = { ...this.defaultOptions, ...options };
+  }
+
+  /**
+   * Load validation schema from a configuration source
+   */
+  async loadValidationSchema(
+    source: ConfigSource,
+    options?: Partial<ConfigLoaderOptions>,
+  ): Promise<ValidationSchema> {
+    const opts = { ...this.defaultOptions, ...options };
+    const cacheKey = this.getCacheKey(source);
+
+    // Check cache first
+    if (opts.cacheEnabled && this.cache.has(cacheKey)) {
+      const cached = this.cache.get(cacheKey)!;
+      if (Date.now() - cached.timestamp < opts.cacheTimeout!) {
+        return cached.data;
+      }
+      this.cache.delete(cacheKey);
+    }
+
+    try {
+      let schema: ValidationSchema;
+
+      switch (source.type) {
+        case 'local':
+          schema = await this.loadLocalSchema(source.path!);
+          break;
+        case 'remote':
+          schema = await this.loadRemoteSchema(source.url!, opts);
+          break;
+        case 'inline':
+          schema = source.data!;
+          break;
+        default:
+          throw new Error(`Unknown config source type: ${source.type}`);
+      }
+
+      // Cache the result
+      if (opts.cacheEnabled) {
+        this.cache.set(cacheKey, { data: schema, timestamp: Date.now() });
+      }
+
+      return schema;
+    } catch (error) {
+      console.warn(
+        `Failed to load validation schema from ${source.type}:`,
+        error,
+      );
+
+      if (opts.fallbackToDefault) {
+        return this.getDefaultSchema();
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Load schema from local file
+   */
+  private async loadLocalSchema(path: string): Promise<ValidationSchema> {
+    try {
+      // For local files, we'll use dynamic imports
+      const module = await import(path);
+      return module.default || module;
+    } catch (error) {
+      throw new Error(`Failed to load local schema from ${path}: ${error}`);
+    }
+  }
+
+  /**
+   * Load schema from remote URL
+   */
+  private async loadRemoteSchema(
+    url: string,
+    options: ConfigLoaderOptions,
+  ): Promise<ValidationSchema> {
+    let lastError: Error;
+
+    for (let attempt = 1; attempt <= options.retryAttempts!; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+        return this.validateSchemaStructure(data);
+      } catch (error) {
+        lastError = error as Error;
+
+        if (attempt < options.retryAttempts!) {
+          await this.delay(options.retryDelay!);
+        }
+      }
+    }
+
+    throw new Error(
+      `Failed to load remote schema after ${options.retryAttempts} attempts: ${lastError!.message}`,
+    );
+  }
+
+  /**
+   * Validate that the loaded data has the correct schema structure
+   */
+  private validateSchemaStructure(data: any): ValidationSchema {
+    // Basic validation - in production, you might want to use a schema validation library
+    if (!data || typeof data !== 'object') {
+      throw new Error('Invalid schema: data is not an object');
+    }
+
+    if (!data.version || !data.globalSettings || !data.dataTypes) {
+      throw new Error(
+        'Invalid schema: missing required fields (version, globalSettings, dataTypes)',
+      );
+    }
+
+    return data as ValidationSchema;
+  }
+
+  /**
+   * Get cache key for a source
+   */
+  private getCacheKey(source: ConfigSource): string {
+    switch (source.type) {
+      case 'local':
+        return `local:${source.path}`;
+      case 'remote':
+        return `remote:${source.url}`;
+      case 'inline':
+        return `inline:${Date.now()}`;
+      default:
+        return `unknown:${JSON.stringify(source)}`;
+    }
+  }
+
+  /**
+   * Delay execution for specified milliseconds
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Get default validation schema
+   */
+  private getDefaultSchema(): ValidationSchema {
+    return {
+      version: '1.0.0',
+      description: 'Default validation schema',
+      globalSettings: {
+        defaultSeverity: 'error',
+        showWarnings: true,
+        strictMode: false,
+      },
+      dataTypes: {
+        String: {
+          validation: {
+            required: {
+              enabled: true,
+              message: 'Value cannot be empty',
+              severity: 'error',
+            },
+          },
+        },
+        Number: {
+          validation: {
+            required: {
+              enabled: true,
+              message: 'Value cannot be empty',
+              severity: 'error',
+            },
+            numeric: {
+              enabled: true,
+              message: 'Value must be a valid number',
+              severity: 'error',
+            },
+          },
+        },
+        Boolean: {
+          validation: {
+            required: {
+              enabled: true,
+              message: 'Value cannot be empty',
+              severity: 'error',
+            },
+            boolean: {
+              enabled: true,
+              message: 'Value must be a valid boolean',
+              severity: 'error',
+            },
+          },
+        },
+      },
+      expressions: {
+        primitive: {
+          validation: {
+            required: {
+              enabled: true,
+              message: 'Value cannot be empty',
+              severity: 'error',
+            },
+          },
+        },
+        operation: {
+          validation: {
+            operands: {
+              required: {
+                enabled: true,
+                message: 'Operand {index} cannot be empty',
+                severity: 'error',
+              },
+            },
+          },
+        },
+      },
+      nodeTypes: {},
+      identifiers: {
+        validation: {
+          required: {
+            enabled: true,
+            message: 'Identifier cannot be empty',
+            severity: 'error',
+          },
+          format: {
+            enabled: true,
+            message: 'Invalid identifier format',
+            severity: 'error',
+          },
+        },
+      },
+      messages: {
+        custom: {
+          emptyValue: 'This field cannot be empty',
+          invalidFormat: 'Invalid format for this field',
+          typeMismatch: 'Value type does not match expected type',
+          validationFailed: 'Validation failed for this field',
+        },
+      },
+    };
+  }
+
+  /**
+   * Clear the configuration cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats(): {
+    size: number;
+    entries: Array<{ key: string; age: number }>;
+  } {
+    const now = Date.now();
+    const entries = Array.from(this.cache.entries()).map(([key, value]) => ({
+      key,
+      age: now - value.timestamp,
+    }));
+
+    return {
+      size: this.cache.size,
+      entries,
+    };
+  }
+}
+
+// Export singleton instance
+export const configLoader = new ConfigLoader();
+
+// Export convenience functions
+export const loadValidationSchema = (
+  source: ConfigSource,
+  options?: Partial<ConfigLoaderOptions>,
+) => configLoader.loadValidationSchema(source, options);
+
+export const loadLocalValidationSchema = (
+  path: string,
+  options?: Partial<ConfigLoaderOptions>,
+) => configLoader.loadValidationSchema({ type: 'local', path }, options);
+
+export const loadRemoteValidationSchema = (
+  url: string,
+  options?: Partial<ConfigLoaderOptions>,
+) => configLoader.loadValidationSchema({ type: 'remote', url }, options);
+
+export const loadInlineValidationSchema = (
+  data: ValidationSchema,
+  options?: Partial<ConfigLoaderOptions>,
+) => configLoader.loadValidationSchema({ type: 'inline', data }, options);

package/packages/diagrams/src/lib/utils/constant-lengths.ts

@@ -1,8 +1,8 @@
-export default {
-    CONNECTION_LENGTH: 100,
-    SUB_NODE_WIDTH: 336,
-    SUB_NODE_HEIGHT: 150,
-    SUB_NODE_MARGIN: 100,
-    ADD_NODE_WIDTH: 150 -36,
-    NODE_TOP_HEIGHT: 200
-}
+export default {
+    CONNECTION_LENGTH: 100,
+    SUB_NODE_WIDTH: 336,
+    SUB_NODE_HEIGHT: 150,
+    SUB_NODE_MARGIN: 100,
+    ADD_NODE_WIDTH: 150 -36,
+    NODE_TOP_HEIGHT: 200
+}