@aitronos/freddy-plugins 0.4.57 → 0.4.59

package/dist/src/composables/useErrorHandler.d.ts

@@ -0,0 +1,46 @@
+export interface ErrorDetails {
+    message: string;
+    code?: string | number;
+    stack?: string;
+    timestamp: string;
+    context?: Record<string, unknown>;
+}
+export interface UseErrorHandlerOptions {
+    logErrors?: boolean;
+    throwOnCritical?: boolean;
+    maxRetries?: number;
+}
+/**
+ * Composable for centralized error handling
+ */
+export declare function useErrorHandler(options?: UseErrorHandlerOptions): {
+    errors: import('vue').ComputedRef<{
+        message: string;
+        code?: string | number | undefined;
+        stack?: string | undefined;
+        timestamp: string;
+        context?: Record<string, unknown> | undefined;
+    }[]>;
+    hasErrors: import('vue').ComputedRef<boolean>;
+    latestError: import('vue').ComputedRef<{
+        message: string;
+        code?: string | number | undefined;
+        stack?: string | undefined;
+        timestamp: string;
+        context?: Record<string, unknown> | undefined;
+    }>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    retryCount: import('vue').ComputedRef<number>;
+    handleError: (error: unknown, context?: Record<string, unknown>) => ErrorDetails;
+    handleAsync: <T>(operation: () => Promise<T>, context?: Record<string, unknown>) => Promise<{
+        data: T | null;
+        error: ErrorDetails | null;
+    }>;
+    retryAsync: <T>(operation: () => Promise<T>, context?: Record<string, unknown>) => Promise<{
+        data: T | null;
+        error: ErrorDetails | null;
+    }>;
+    clearErrors: () => void;
+    clearError: (index: number) => void;
+    isCriticalError: (error: unknown) => boolean;
+};

package/dist/src/composables/usePerformance.d.ts

@@ -0,0 +1,54 @@
+export interface PerformanceMetrics {
+    renderTime: number;
+    componentCount: number;
+    memoryUsage?: number;
+    timestamp: string;
+}
+export interface UsePerformanceOptions {
+    enableMetrics?: boolean;
+    trackMemory?: boolean;
+    sampleRate?: number;
+}
+/**
+ * Composable for performance monitoring and optimization
+ */
+export declare function usePerformance(options?: UsePerformanceOptions): {
+    metrics: import('vue').ComputedRef<{
+        renderTime: number;
+        componentCount: number;
+        memoryUsage?: number | undefined;
+        timestamp: string;
+    }[]>;
+    isTracking: import('vue').ComputedRef<boolean>;
+    averageRenderTime: import('vue').ComputedRef<number>;
+    maxRenderTime: import('vue').ComputedRef<number>;
+    startTracking: (label?: string) => void;
+    endTracking: (label?: string, componentCount?: number) => PerformanceMetrics | undefined;
+    measureAsync: <T>(operation: () => Promise<T>, label?: string) => Promise<{
+        result: T;
+        metrics: PerformanceMetrics;
+    }>;
+    debounce: <T extends (...args: any[]) => any>(func: T, wait: number) => ((...args: Parameters<T>) => void);
+    throttle: <T extends (...args: any[]) => any>(func: T, limit: number) => ((...args: Parameters<T>) => void);
+    scheduleWork: (callback: () => void, timeout?: number) => void;
+    lazyLoad: <T>(loader: () => Promise<T>, delay?: number) => Promise<T>;
+    createVirtualList: <T>(items: T[], itemHeight: number, containerHeight: number) => (scrollTop: number) => {
+        visibleItems: T[];
+        startIndex: number;
+        endIndex: number;
+        totalHeight: number;
+        offsetY: number;
+    };
+    clearMetrics: () => void;
+    getSummary: () => {
+        totalMeasurements: number;
+        averageRenderTime: number;
+        maxRenderTime: number;
+        recentMetrics: {
+            renderTime: number;
+            componentCount: number;
+            memoryUsage?: number | undefined;
+            timestamp: string;
+        }[];
+    };
+};

package/dist/src/composables/useTheme.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useTheme Composable - DEPRECATED in v0.4.54
+ *
+ * ⚠️ ThemeService was removed due to SSR incompatibility
+ * This stub prevents build errors but returns no-op functions
+ *
+ * For theme functionality, implement theme management in your consuming app
+ * Recovery: git checkout 70edb4d (v0.4.53) for full implementation
+ *
+ * @deprecated Use your app's theme system instead
+ */
+export declare const useTheme: () => {
+    currentProject: import('vue').Ref<null, null>;
+    currentColorMode: import('vue').Ref<null, null>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<null, null>;
+    availableBrands: import('vue').ComputedRef<never[]>;
+    availableModes: import('vue').ComputedRef<never[]>;
+    setBrand: () => void;
+    setMode: () => void;
+    setTheme: () => void;
+    initializeTheme: () => Promise<void>;
+};
+export declare const useThemeState: () => {
+    currentProject: import('vue').Ref<null, null>;
+    currentColorMode: import('vue').Ref<null, null>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<null, null>;
+    availableBrands: import('vue').ComputedRef<never[]>;
+    availableModes: import('vue').ComputedRef<never[]>;
+};
+export declare const useThemeActions: () => {
+    setBrand: () => void;
+    setMode: () => void;
+    setTheme: () => void;
+    initializeTheme: () => Promise<void>;
+};

package/dist/src/config/api.config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Get the current environment from localStorage or default to local
+ */
+/**
+ * Get the current Flowplate environment from localStorage or default to production
+ */
+/**
+ * Get the base API endpoint for the current environment
+ */
+export declare function getApiBaseUrl(): any;
+/**
+ * Get the Flowplate API base URL for the current environment
+ */
+export declare function getFlowplateBaseUrl(): any;
+/**
+ * Get the upload API endpoint for the current environment
+ */
+export declare function getUploadUrl(): any;
+/**
+ * Get the auth API endpoint
+ * Auth endpoints are always under /auth path
+ */
+export declare function getAuthBaseUrl(): any;
+/**
+ * Get environment configuration
+ */
+export declare function getEnvironmentConfig(): void;
+/**
+ * Get Flowplate environment configuration
+ */
+export declare function getFlowplateEnvironmentConfig(): void;

package/dist/src/config/colors/brands/contentplate.colors.d.ts

@@ -0,0 +1,3 @@
+import { BrandConfig } from '../types/color.types';
+export declare const contentplateConfig: BrandConfig;
+export default contentplateConfig;

package/dist/src/config/colors/brands/flowplate.colors.d.ts

@@ -0,0 +1,3 @@
+import { BrandConfig } from '../types/color.types';
+export declare const flowplateConfig: BrandConfig;
+export default flowplateConfig;

package/dist/src/config/colors/brands/freddy.colors.d.ts

@@ -0,0 +1,3 @@
+import { BrandConfig } from '../types/color.types';
+export declare const freddyConfig: BrandConfig;
+export default freddyConfig;

package/dist/src/config/colors/color-system.d.ts

@@ -0,0 +1,58 @@
+import { ColorSystemConfig, ColorToken, BrandColors, ColorMode, ColorUtils, ColorValidationResult, CSSColorProperties } from './types/color.types';
+export declare const colorSystemConfig: ColorSystemConfig;
+/**
+ * Gets a color value based on a color token
+ */
+export declare const getColor: (token: ColorToken) => string;
+/**
+ * Gets all colors for a specific brand and mode
+ */
+export declare const getBrandColors: (brand: string, mode?: "light" | "dark" | "default") => BrandColors;
+/**
+ * Gets mode-specific colors
+ */
+export declare const getModeColors: (mode: "light" | "dark") => ColorMode;
+/**
+ * Validates contrast between two colors
+ */
+export declare const validateColorContrast: (foreground: string, background: string) => ColorValidationResult;
+/**
+ * Generates a color scale from a base color
+ */
+export declare const generateColorScaleFromBase: (baseColor: string, steps?: number) => import('./types/color.types').ColorPalette;
+/**
+ * Gets appropriate text color for a background
+ */
+export declare const getAppropriateTextColor: (backgroundColor: string) => string;
+/**
+ * Validates if a color is a valid hex color
+ */
+export declare const isValidColor: (color: string) => boolean;
+/**
+ * Normalizes a hex color
+ */
+export declare const normalizeColor: (color: string) => string;
+/**
+ * Generates CSS custom properties for a brand and mode
+ */
+export declare const generateCSSProperties: (brand: string, mode?: "light" | "dark") => CSSColorProperties;
+/**
+ * Color utilities object
+ */
+export declare const colorUtils: ColorUtils;
+/**
+ * Vue composable for using the color system
+ */
+export declare const useColorSystem: () => {
+    getColor: (token: ColorToken) => string;
+    getBrandColors: (brand: string, mode?: "light" | "dark" | "default") => BrandColors;
+    getModeColors: (mode: "light" | "dark") => ColorMode;
+    validateColorContrast: (foreground: string, background: string) => ColorValidationResult;
+    generateColorScaleFromBase: (baseColor: string, steps?: number) => import('./types/color.types').ColorPalette;
+    getAppropriateTextColor: (backgroundColor: string) => string;
+    isValidColor: (color: string) => boolean;
+    normalizeColor: (color: string) => string;
+    generateCSSProperties: (brand: string, mode?: "light" | "dark") => CSSColorProperties;
+    config: ColorSystemConfig;
+};
+export default colorSystemConfig;

package/dist/src/config/colors/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Color System Index
+ *
+ * Main exports for the color system
+ */
+export type { ColorScale, ColorPalette, BrandColors, ColorMode, BrandConfig, ColorSystemConfig, ColorToken, ColorUtils, CSSColorProperties, GeneratedColorConfig, ColorValidationResult, BrandName, ModeName, ColorCategory, SemanticColorType, InteractiveStateType } from './types/color.types';
+export { interpolateColor, hexToRgb, rgbToHex, getLuminance, getContrastRatio, validateContrast, generateColorScale, addOpacity, hexToHsl, hslToHex, adjustLightness, adjustSaturation, adjustHue, getComplementary, getAnalogous, getTriadic, getTetradic, isLightColor, getTextColor, isValidHexColor, normalizeHexColor } from './utils/color.utils';
+export { colorSystemConfig, getColor, getBrandColors, getModeColors, validateColorContrast, generateColorScaleFromBase, getAppropriateTextColor, isValidColor, normalizeColor, generateCSSProperties, colorUtils, useColorSystem } from './color-system';
+export { default as contentplateConfig } from './brands/contentplate.colors';
+export { default as flowplateConfig } from './brands/flowplate.colors';
+export { default as freddyConfig } from './brands/freddy.colors';
+export { default } from './color-system';

package/dist/src/config/colors/types/color-system.types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Color System Types
+ * Color system type definitions
+ */
+export interface ColorValue {
+    name: string;
+    value: string | null;
+    description: string;
+    id: string | null;
+}
+export interface ColorCategory {
+    [key: string]: ColorValue;
+}
+export interface ColorCategories {
+    text: ColorCategory;
+    background: ColorCategory;
+    border: ColorCategory;
+    foreground: ColorCategory;
+    utility: ColorCategory;
+}
+export interface ColorMode {
+    name: string;
+    colors: ColorCategories;
+}
+export interface ColorModes {
+    [key: string]: ColorMode;
+}
+export interface Brand {
+    name: string;
+    modes: ColorModes;
+}
+export interface BrandStats {
+    totalModes: number;
+    totalColors: number;
+    missingColors: number;
+}
+export interface ValidationStats {
+    totalBrands: number;
+    totalModes: number;
+    totalColors: number;
+    missingColors: number;
+    brandStats: {
+        [key: string]: BrandStats;
+    };
+}
+export interface ColorSystemMetadata {
+    generatedAt: string;
+    source: string;
+    brands: string[];
+    modes: string[];
+    totalColors: number;
+    validation: ValidationStats;
+}
+export interface ColorSystem {
+    metadata: ColorSystemMetadata;
+    brands: {
+        [key: string]: Brand;
+    };
+}
+export type ColorKey = keyof ColorCategories;
+export type ModeKey = 'default' | 'light' | 'dark';
+export type BrandKey = 'freddy' | 'flowplate' | 'contentplate';

package/dist/src/config/colors/types/color.types.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Color System Type Definitions
+ *
+ * This file defines the TypeScript interfaces for the color system
+ * that supports multiple brands and color modes.
+ */
+export type ColorScale = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+export interface ColorPalette {
+    [key: string]: string | ColorScale;
+}
+export interface BrandColors {
+    primary: ColorPalette;
+    secondary?: ColorPalette;
+    neutral: ColorPalette;
+    semantic: {
+        success: ColorPalette;
+        warning: ColorPalette;
+        error: ColorPalette;
+        info: ColorPalette;
+    };
+    interactive: {
+        hover: ColorPalette;
+        focus: ColorPalette;
+        active: ColorPalette;
+        disabled: ColorPalette;
+    };
+    background: ColorPalette;
+    text: ColorPalette;
+    border: ColorPalette;
+}
+export interface ColorMode {
+    name: 'light' | 'dark';
+    background: ColorPalette;
+    text: ColorPalette;
+    border: ColorPalette;
+    overlay: ColorPalette;
+}
+export interface BrandConfig {
+    name: string;
+    colors: BrandColors;
+    modes: {
+        light: ColorMode;
+        dark: ColorMode;
+    };
+}
+export interface ColorSystemConfig {
+    brands: {
+        contentplate: BrandConfig;
+        flowplate: BrandConfig;
+        freddy: BrandConfig;
+    };
+    modes: {
+        light: ColorMode;
+        dark: ColorMode;
+    };
+}
+export interface ColorToken {
+    brand: 'contentplate' | 'flowplate' | 'freddy';
+    mode: 'light' | 'dark';
+    category: 'primary' | 'secondary' | 'neutral' | 'semantic' | 'interactive' | 'background' | 'text' | 'border';
+    scale?: ColorScale;
+    variant?: string;
+}
+export interface ColorUtils {
+    getColor: (token: ColorToken) => string;
+    getBrandColors: (brand: string, mode?: 'light' | 'dark') => BrandColors;
+    getModeColors: (mode: 'light' | 'dark') => ColorMode;
+    interpolateColor: (start: string, end: string, steps: number) => string[];
+    validateContrast: (foreground: string, background: string) => boolean;
+    generateColorScale: (baseColor: string, steps?: number) => ColorPalette;
+}
+export interface CSSColorProperties {
+    [key: string]: string;
+}
+export interface GeneratedColorConfig {
+    brands: {
+        [brand: string]: {
+            colors: BrandColors;
+            modes: {
+                light: ColorMode;
+                dark: ColorMode;
+            };
+        };
+    };
+    cssProperties: CSSColorProperties;
+    typescriptDefinitions: string;
+}
+export interface ColorValidationResult {
+    isValid: boolean;
+    contrastRatio: number;
+    isAccessible: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export type BrandName = 'contentplate' | 'flowplate' | 'freddy';
+export type ModeName = 'light' | 'dark';
+export type ColorCategory = 'primary' | 'secondary' | 'neutral' | 'semantic' | 'interactive' | 'background' | 'text' | 'border';
+export type SemanticColorType = 'success' | 'warning' | 'error' | 'info';
+export type InteractiveStateType = 'hover' | 'focus' | 'active' | 'disabled';

package/dist/src/config/colors/utils/color.utils.d.ts

@@ -0,0 +1,86 @@
+import { ColorPalette, ColorValidationResult } from '../types/color.types';
+/**
+ * Generates a series of interpolated colors between two colors.
+ * Enhanced version of the existing interpolateColor function.
+ */
+export declare const interpolateColor: (start: string, end: string, steps: number) => string[];
+/**
+ * Converts hex color to RGB values
+ */
+export declare const hexToRgb: (hex: string) => [number, number, number];
+/**
+ * Converts RGB values to hex color
+ */
+export declare const rgbToHex: (r: number, g: number, b: number) => string;
+/**
+ * Calculates the relative luminance of a color
+ */
+export declare const getLuminance: (r: number, g: number, b: number) => number;
+/**
+ * Calculates contrast ratio between two colors
+ */
+export declare const getContrastRatio: (color1: string, color2: string) => number;
+/**
+ * Validates color contrast for accessibility
+ */
+export declare const validateContrast: (foreground: string, background: string) => ColorValidationResult;
+/**
+ * Generates a color scale from a base color
+ */
+export declare const generateColorScale: (baseColor: string, steps?: number) => ColorPalette;
+/**
+ * Adds opacity to a hex color
+ */
+export declare const addOpacity: (hex: string, opacity: number) => string;
+/**
+ * Converts hex color to HSL
+ */
+export declare const hexToHsl: (hex: string) => [number, number, number];
+/**
+ * Converts HSL to hex color
+ */
+export declare const hslToHex: (h: number, s: number, l: number) => string;
+/**
+ * Adjusts the lightness of a color
+ */
+export declare const adjustLightness: (hex: string, amount: number) => string;
+/**
+ * Adjusts the saturation of a color
+ */
+export declare const adjustSaturation: (hex: string, amount: number) => string;
+/**
+ * Adjusts the hue of a color
+ */
+export declare const adjustHue: (hex: string, amount: number) => string;
+/**
+ * Creates a complementary color
+ */
+export declare const getComplementary: (hex: string) => string;
+/**
+ * Creates an analogous color palette
+ */
+export declare const getAnalogous: (hex: string, count?: number) => string[];
+/**
+ * Creates a triadic color palette
+ */
+export declare const getTriadic: (hex: string) => string[];
+/**
+ * Creates a tetradic color palette
+ */
+export declare const getTetradic: (hex: string) => string[];
+/**
+ * Checks if a color is light or dark
+ */
+export declare const isLightColor: (hex: string) => boolean;
+/**
+ * Gets the appropriate text color for a background
+ */
+export declare const getTextColor: (backgroundColor: string) => string;
+/**
+ * Validates if a string is a valid hex color
+ */
+export declare const isValidHexColor: (hex: string) => boolean;
+/**
+ * Normalizes a hex color (ensures 6-digit format)
+ */
+export declare const normalizeHexColor: (hex: string) => string;

package/dist/src/config/environments.d.ts

@@ -0,0 +1,11 @@
+export interface EnvironmentConfig {
+    baseEndpoint: string;
+    uploadEndpoint: string;
+    name: string;
+}
+export interface FlowplateEnvironmentConfig {
+    baseEndpoint: string;
+    name: string;
+}
+export declare const environments: Record<string, EnvironmentConfig>;
+export declare const flowplateEnvironments: Record<string, FlowplateEnvironmentConfig>;

package/dist/src/config/theme/freddy-default.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Freddy Theme — Default (Dark)
+ *
+ * Sections
+ *  - Texts
+ *  - Base
+ *  - Foreground (neutrals)
+ *  - Background
+ *  - Border
+ *  - Utility scales
+ *  - Design tokens (spacing, typography, radius, shadows)
+ *  - Button tokens
+ *  - Brand tokens (primary)
+ */
+declare const freddyDefaultVars: Record<string, string>;
+export default freddyDefaultVars;

package/dist/src/config/theme/freddy-light.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Freddy Theme — Light (White)
+ *
+ * Sections
+ *  - Texts
+ *  - Base
+ *  - Foreground (neutrals)
+ *  - Background
+ *  - Border
+ *  - Utility scales
+ *  - Semantic/brand/button tokens
+ */
+declare const freddyLightVars: Record<string, string>;
+export default freddyLightVars;

package/dist/src/config/theme/global-theme-store.d.ts

@@ -0,0 +1,128 @@
+declare const currentBrand: import('vue').Ref<string, string>;
+declare const currentMode: import('vue').Ref<string, string>;
+declare const isThemeLoading: import('vue').Ref<boolean, boolean>;
+export interface ThemeState {
+    brand: string;
+    mode: string;
+    isLoading: boolean;
+}
+export interface ThemeActions {
+    setBrand: (brand: string) => void;
+    setMode: (mode: string) => void;
+    setTheme: (brand: string, mode: string) => void;
+    applyTheme: () => void;
+    loadSavedTheme: () => boolean;
+    saveTheme: () => void;
+    clearSavedTheme: () => void;
+}
+declare const currentTheme: import('vue').ComputedRef<string>;
+declare const brandColors: import('vue').ComputedRef<import('../colors').BrandColors>;
+export declare const useGlobalTheme: () => {
+    currentBrand: Readonly<import('vue').Ref<string, string>>;
+    currentMode: Readonly<import('vue').Ref<string, string>>;
+    currentTheme: Readonly<import('vue').Ref<string, string>>;
+    brandColors: Readonly<import('vue').Ref<{
+        readonly primary: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly secondary?: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        } | undefined;
+        readonly neutral: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly semantic: {
+            readonly success: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly warning: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly error: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly info: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+        };
+        readonly interactive: {
+            readonly hover: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly focus: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly active: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly disabled: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+        };
+        readonly background: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly text: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly border: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+    }, {
+        readonly primary: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly secondary?: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        } | undefined;
+        readonly neutral: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly semantic: {
+            readonly success: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly warning: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly error: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly info: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+        };
+        readonly interactive: {
+            readonly hover: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly focus: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly active: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+            readonly disabled: {
+                readonly [x: string]: string | import('../colors').ColorScale;
+            };
+        };
+        readonly background: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly text: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+        readonly border: {
+            readonly [x: string]: string | import('../colors').ColorScale;
+        };
+    }>>;
+    isLoading: Readonly<import('vue').Ref<boolean, boolean>>;
+    setBrand: (brand: string) => void;
+    setMode: (mode: string) => void;
+    setTheme: (brand: string, mode: string) => void;
+    applyTheme: () => Promise<void>;
+    loadSavedTheme: () => boolean;
+    saveTheme: () => void;
+    clearSavedTheme: () => void;
+};
+export { currentBrand, currentMode, currentTheme, brandColors, isThemeLoading };