@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.6 → 0.2.8

package/dist/themes/inheritance.d.ts

@@ -0,0 +1,160 @@
+
+function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+  const result = { ...target };
+
+  for (const key in source) {
+    if (source[key] !== undefined) {
+      if (
+        typeof source[key] === 'object' && 
+        source[key] !== null && 
+        !Array.isArray(source[key]) &&
+        typeof target[key] === 'object' &&
+        target[key] !== null &&
+        !Array.isArray(target[key])
+      ) {
+        // Recursively merge objects
+        result[key] = deepMerge(target[key], source[key]);
+      } else {
+        // Direct assignment for primitives, arrays, or null values
+        result[key] = source[key] as T[Extract<keyof T, string>];
+      }
+    }
+  }
+
+  return result;
+}
+
+export function applyThemeInheritance(theme: Partial<MultiThemeConfig>): MultiThemeConfig {
+  return deepMerge(defaultTheme, theme);
+}
+
+export function createTheme(themeConfig: Partial<MultiThemeConfig>): MultiThemeConfig {
+  return applyThemeInheritance(themeConfig);
+}
+
+export function validateThemeCompleteness(theme: MultiThemeConfig): string[] {
+  const missingPaths: string[] = [];
+
+  function checkObject(obj: any, defaultObj: any, path: string = '') {
+    for (const key in defaultObj) {
+      const currentPath = path ? `${path}.${key}` : key;
+
+      if (obj[key] === undefined) {
+        missingPaths.push(currentPath);
+      } else if (
+        typeof defaultObj[key] === 'object' && 
+        defaultObj[key] !== null && 
+        !Array.isArray(defaultObj[key])
+      ) {
+        checkObject(obj[key], defaultObj[key], currentPath);
+      }
+    }
+  }
+
+  checkObject(theme, defaultTheme);
+  return missingPaths;
+}
+
+export declare const themeInheritanceManager: {
+  // Internal theme registry
+  _themes: new Map<string, MultiThemeConfig>(),
+
+  applyInheritance: applyThemeInheritance,
+
+  createTheme,
+
+  getDefaultTheme: () => defaultTheme,
+
+  validateCompleteness: validateThemeCompleteness,
+
+  hasInheritance: (theme: MultiThemeConfig): boolean => {
+    const missing = validateThemeCompleteness(theme);
+    return missing.length === 0;
+  },
+
+  getProperty: <T>(theme: MultiThemeConfig, path: string, fallback?: T): T => {
+    const keys = path.split('.');
+    let current: any = theme;
+
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        // Fall back to default theme
+        current = defaultTheme;
+        for (const key of keys) {
+          if (current && typeof current === 'object' && key in current) {
+            current = current[key];
+          } else {
+            return fallback as T;
+          }
+        }
+        break;
+      }
+    }
+
+    return current as T;
+  },
+
+  registerTheme: (name: string, theme: Partial<MultiThemeConfig>): MultiThemeConfig => {
+    const themeWithInheritance = applyThemeInheritance(theme);
+    themeInheritanceManager._themes.set(name, themeWithInheritance);
+    return themeWithInheritance;
+  },
+
+  getCompleteTheme: (name: string): CompleteThemeConfig | null => {
+    // First try to get the registered theme
+    const registeredTheme = themeInheritanceManager._themes.get(name);
+    if (registeredTheme) {
+      // Check if this theme extends another theme that exists
+      if (registeredTheme.extends && !themeInheritanceManager._themes.has(registeredTheme.extends)) {
+        // Theme extends a missing parent, return null
+        return null;
+      }
+      return toCompleteThemeConfig(registeredTheme);
+    }
+
+    // Fall back to default theme if the requested theme is not found
+    if (name === 'default' || name === 'stan-design') {
+      return toCompleteThemeConfig(defaultTheme);
+    }
+
+    return null;
+  },
+
+  getRegisteredThemeNames: (): string[] => {
+    return Array.from(themeInheritanceManager._themes.keys());
+  },
+
+  isThemeRegistered: (name: string): boolean => {
+    return themeInheritanceManager._themes.has(name);
+  }
+};
+
+export function withInheritance(themeConfig: Partial<MultiThemeConfig>) {
+  return function <T extends { new (...args: any[]): any }>(constructor: T) {
+    return class extends constructor {
+      static theme = applyThemeInheritance(themeConfig);
+    };
+  };
+}
+
+export type PartialThemeConfig = Partial<MultiThemeConfig>;
+
+export function overrideTheme(
+  baseTheme: MultiThemeConfig, 
+  overrides: Partial<MultiThemeConfig>
+): MultiThemeConfig {
+  return deepMerge(baseTheme, overrides);
+}
+
+export function toCompleteThemeConfig(theme: MultiThemeConfig): CompleteThemeConfig {
+  return {
+    ...theme,
+    validation: {
+      isValid: true,
+      errors: [],
+      warnings: []
+    }
+  };
+}

package/dist/themes/inheritance.esm.js

@@ -0,0 +1,219 @@
+import { MultiThemeConfig, CompleteThemeConfig } from './types';
+import { defaultTheme } from './themes/default';
+
+/**
+ * Deep merge utility for theme inheritance
+ * Recursively merges theme configuration with default values
+ */
+function deepMerge<T extends Record<string, any>>(target, source)= { ...target };
+  
+  for (const key in source) {
+    if (source[key] !== undefined) {
+      if (
+        typeof source[key] === 'object' && 
+        source[key] !== null && 
+        !Array.isArray(source[key]) &&
+        typeof target[key] === 'object' &&
+        target[key] !== null &&
+        !Array.isArray(target[key])
+      ) {
+        // Recursively merge objects
+        result[key] = deepMerge(target[key], source[key]);
+      } else {
+        // Direct assignment for primitives, arrays, or null values
+        result[key] = source[key] as T[Extract<keyof T, string>];
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Apply theme inheritance by merging with default theme
+ * Any undefined values in the theme will be filled with defaults
+ */
+export function applyThemeInheritance(theme), theme);
+}
+
+/**
+ * Create a theme with inheritance support
+ * This is the recommended way to define new themes
+ */
+export function createTheme(themeConfig));
+}
+
+/**
+ * Validate that a theme has all required properties
+ * Returns an array of missing property paths
+ */
+export function validateThemeCompleteness(theme)] {
+  const missingPaths] = [];
+  
+  function checkObject(obj, defaultObj, path= '') {
+    for (const key in defaultObj) {
+      const currentPath = path ? `${path}.${key}` ;
+      
+      if (obj[key] === undefined) {
+        missingPaths.push(currentPath);
+      } else if (
+        typeof defaultObj[key] === 'object' && 
+        defaultObj[key] !== null && 
+        !Array.isArray(defaultObj[key])
+      ) {
+        checkObject(obj[key], defaultObj[key], currentPath);
+      }
+    }
+  }
+  
+  checkObject(theme, defaultTheme);
+  return missingPaths;
+}
+
+/**
+ * Theme inheritance manager
+ * Provides utilities for working with theme inheritance
+ */
+export const themeInheritanceManager = {
+  // Internal theme registry
+  _themes, MultiThemeConfig>(),
+  
+  /**
+   * Apply inheritance to a theme
+   */
+  applyInheritance,
+  
+  /**
+   * Create a new theme with inheritance
+   */
+  createTheme,
+  
+  /**
+   * Get the default theme
+   */
+  getDefaultTheme) => defaultTheme,
+  
+  /**
+   * Validate theme completeness
+   */
+  validateCompleteness,
+  
+  /**
+   * Check if a theme has inheritance applied
+   */
+  hasInheritance)=> {
+    const missing = validateThemeCompleteness(theme);
+    return missing.length === 0;
+  },
+  
+  /**
+   * Get theme property with fallback to default
+   */
+  getProperty, path, fallback?)=> {
+    const keys = path.split('.');
+    let current= theme;
+    
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        // Fall back to default theme
+        current = defaultTheme;
+        for (const key of keys) {
+          if (current && typeof current === 'object' && key in current) {
+            current = current[key];
+          } else {
+            return fallback as T;
+          }
+        }
+        break;
+      }
+    }
+    
+    return current as T;
+  },
+  
+  /**
+   * Register a theme with inheritance applied
+   */
+  registerTheme, theme)=> {
+    const themeWithInheritance = applyThemeInheritance(theme);
+    themeInheritanceManager._themes.set(name, themeWithInheritance);
+    return themeWithInheritance;
+  },
+  
+  /**
+   * Get complete theme with inheritance applied
+   */
+  getCompleteTheme)=> {
+    // First try to get the registered theme
+    const registeredTheme = themeInheritanceManager._themes.get(name);
+    if (registeredTheme) {
+      // Check if this theme extends another theme that exists
+      if (registeredTheme.extends && !themeInheritanceManager._themes.has(registeredTheme.extends)) {
+        // Theme extends a missing parent, return null
+        return null;
+      }
+      return toCompleteThemeConfig(registeredTheme);
+    }
+    
+    // Fall back to default theme if the requested theme is not found
+    if (name === 'default' || name === 'stan-design') {
+      return toCompleteThemeConfig(defaultTheme);
+    }
+    
+    return null;
+  },
+  
+  /**
+   * Get all registered theme names
+   */
+  getRegisteredThemeNames)] => {
+    return Array.from(themeInheritanceManager._themes.keys());
+  },
+  
+  /**
+   * Check if a theme is registered
+   */
+  isThemeRegistered)=> {
+    return themeInheritanceManager._themes.has(name);
+  }
+};
+
+/**
+ * Theme inheritance decorator
+ * Use this to automatically apply inheritance when defining themes
+ */
+export function withInheritance(themeConfig) {
+  return function <T extends { new (...args])}>(constructor) {
+    return class extends constructor {
+      static theme = applyThemeInheritance(themeConfig);
+    };
+  };
+}
+
+/**
+ * Partial theme type for theme definitions
+ * Use this when you only want to define specific parts of a theme
+ */
+
+
+/**
+ * Theme override utility
+ * Allows you to override specific parts of an existing theme
+ */
+export function overrideTheme(
+  baseTheme, 
+  overrides), overrides);
+}
+
+/**
+ * Convert MultiThemeConfig to CompleteThemeConfig
+ */
+export function toCompleteThemeConfig(theme),
+    validation,
+      errors],
+      warnings]
+    }
+  };
+}

package/dist/themes/inheritance.js

@@ -0,0 +1,219 @@
+import { MultiThemeConfig, CompleteThemeConfig } from './types';
+import { defaultTheme } from './themes/default';
+
+/**
+ * Deep merge utility for theme inheritance
+ * Recursively merges theme configuration with default values
+ */
+function deepMerge<T extends Record<string, any>>(target, source)= { ...target };
+  
+  for (const key in source) {
+    if (source[key] !== undefined) {
+      if (
+        typeof source[key] === 'object' && 
+        source[key] !== null && 
+        !Array.isArray(source[key]) &&
+        typeof target[key] === 'object' &&
+        target[key] !== null &&
+        !Array.isArray(target[key])
+      ) {
+        // Recursively merge objects
+        result[key] = deepMerge(target[key], source[key]);
+      } else {
+        // Direct assignment for primitives, arrays, or null values
+        result[key] = source[key] as T[Extract<keyof T, string>];
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Apply theme inheritance by merging with default theme
+ * Any undefined values in the theme will be filled with defaults
+ */
+export function applyThemeInheritance(theme), theme);
+}
+
+/**
+ * Create a theme with inheritance support
+ * This is the recommended way to define new themes
+ */
+export function createTheme(themeConfig));
+}
+
+/**
+ * Validate that a theme has all required properties
+ * Returns an array of missing property paths
+ */
+export function validateThemeCompleteness(theme)] {
+  const missingPaths] = [];
+  
+  function checkObject(obj, defaultObj, path= '') {
+    for (const key in defaultObj) {
+      const currentPath = path ? `${path}.${key}` ;
+      
+      if (obj[key] === undefined) {
+        missingPaths.push(currentPath);
+      } else if (
+        typeof defaultObj[key] === 'object' && 
+        defaultObj[key] !== null && 
+        !Array.isArray(defaultObj[key])
+      ) {
+        checkObject(obj[key], defaultObj[key], currentPath);
+      }
+    }
+  }
+  
+  checkObject(theme, defaultTheme);
+  return missingPaths;
+}
+
+/**
+ * Theme inheritance manager
+ * Provides utilities for working with theme inheritance
+ */
+export const themeInheritanceManager = {
+  // Internal theme registry
+  _themes, MultiThemeConfig>(),
+  
+  /**
+   * Apply inheritance to a theme
+   */
+  applyInheritance,
+  
+  /**
+   * Create a new theme with inheritance
+   */
+  createTheme,
+  
+  /**
+   * Get the default theme
+   */
+  getDefaultTheme) => defaultTheme,
+  
+  /**
+   * Validate theme completeness
+   */
+  validateCompleteness,
+  
+  /**
+   * Check if a theme has inheritance applied
+   */
+  hasInheritance)=> {
+    const missing = validateThemeCompleteness(theme);
+    return missing.length === 0;
+  },
+  
+  /**
+   * Get theme property with fallback to default
+   */
+  getProperty, path, fallback?)=> {
+    const keys = path.split('.');
+    let current= theme;
+    
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        // Fall back to default theme
+        current = defaultTheme;
+        for (const key of keys) {
+          if (current && typeof current === 'object' && key in current) {
+            current = current[key];
+          } else {
+            return fallback as T;
+          }
+        }
+        break;
+      }
+    }
+    
+    return current as T;
+  },
+  
+  /**
+   * Register a theme with inheritance applied
+   */
+  registerTheme, theme)=> {
+    const themeWithInheritance = applyThemeInheritance(theme);
+    themeInheritanceManager._themes.set(name, themeWithInheritance);
+    return themeWithInheritance;
+  },
+  
+  /**
+   * Get complete theme with inheritance applied
+   */
+  getCompleteTheme)=> {
+    // First try to get the registered theme
+    const registeredTheme = themeInheritanceManager._themes.get(name);
+    if (registeredTheme) {
+      // Check if this theme extends another theme that exists
+      if (registeredTheme.extends && !themeInheritanceManager._themes.has(registeredTheme.extends)) {
+        // Theme extends a missing parent, return null
+        return null;
+      }
+      return toCompleteThemeConfig(registeredTheme);
+    }
+    
+    // Fall back to default theme if the requested theme is not found
+    if (name === 'default' || name === 'stan-design') {
+      return toCompleteThemeConfig(defaultTheme);
+    }
+    
+    return null;
+  },
+  
+  /**
+   * Get all registered theme names
+   */
+  getRegisteredThemeNames)] => {
+    return Array.from(themeInheritanceManager._themes.keys());
+  },
+  
+  /**
+   * Check if a theme is registered
+   */
+  isThemeRegistered)=> {
+    return themeInheritanceManager._themes.has(name);
+  }
+};
+
+/**
+ * Theme inheritance decorator
+ * Use this to automatically apply inheritance when defining themes
+ */
+export function withInheritance(themeConfig) {
+  return function <T extends { new (...args])}>(constructor) {
+    return class extends constructor {
+      static theme = applyThemeInheritance(themeConfig);
+    };
+  };
+}
+
+/**
+ * Partial theme type for theme definitions
+ * Use this when you only want to define specific parts of a theme
+ */
+
+
+/**
+ * Theme override utility
+ * Allows you to override specific parts of an existing theme
+ */
+export function overrideTheme(
+  baseTheme, 
+  overrides), overrides);
+}
+
+/**
+ * Convert MultiThemeConfig to CompleteThemeConfig
+ */
+export function toCompleteThemeConfig(theme),
+    validation,
+      errors],
+      warnings]
+    }
+  };
+}