@kupola/kupola 1.2.0 → 1.4.0

package/dist/utils/utils/kupola.rb

@@ -1,69 +0,0 @@
-module Kupola
-  def self.button(label, variant = 'brand', size = 'md')
-    "<button class=\"ds-btn ds-btn--#{variant} ds-btn--#{size}\">#{label}</button>"
-  end
-
-  def self.input(label, name, placeholder, validate = '')
-    validate_attr = validate.empty? ? '' : " data-validate=\"#{validate}\""
-    <<~HTML
-      <div class="ds-form-item">
-        <label class="ds-form-item__label">#{label}</label>
-        <input type="text" class="ds-input" name="#{name}" placeholder="#{placeholder}"#{validate_attr}>
-      </div>
-    HTML
-  end
-
-  def self.card(title, body, footer = '')
-    footer_html = footer.empty? ? '' : "<div class=\"ds-card__footer\">#{footer}</div>"
-    <<~HTML
-      <div class="ds-card">
-        <div class="ds-card__header">
-          <h3 class="ds-card__title">#{title}</h3>
-        </div>
-        <div class="ds-card__body">#{body}</div>
-        #{footer_html}
-      </div>
-    HTML
-  end
-
-  def self.stat_card(title, value, trend = '', trend_type = 'up')
-    trend_class = trend_type == 'down' ? 'ds-stat-card__trend--down' : 'ds-stat-card__trend--up'
-    trend_html = trend.empty? ? '' : "<span class=\"ds-stat-card__trend #{trend_class}\">#{trend}</span>"
-    <<~HTML
-      <div class="ds-stat-card">
-        <div class="ds-stat-card__title">#{title}</div>
-        <div class="ds-stat-card__value">#{value}</div>
-        #{trend_html}
-      </div>
-    HTML
-  end
-
-  def self.badge(text, variant = 'default')
-    "<span class=\"ds-badge ds-badge--#{variant}\">#{text}</span>"
-  end
-
-  def self.avatar(initials, size = 'md', variant = 'default')
-    "<div class=\"ds-avatar ds-avatar--#{size} ds-avatar--#{variant}\">#{initials}</div>"
-  end
-
-  def self.theme_script(theme = 'dark', brand = 'zengqing')
-    <<~HTML
-      <script>
-        if (typeof setTheme === 'function') setTheme('#{theme}');
-        if (typeof setBrand === 'function') setBrand('#{brand}');
-      </script>
-    HTML
-  end
-
-  def self.data_bind(key, bind_type)
-    "data-bind=\"#{key}:#{bind_type}\""
-  end
-
-  def self.data_component(name)
-    "data-component=\"#{name}\""
-  end
-
-  def self.data_validate(rules)
-    "data-validate=\"#{rules}\""
-  end
-end

package/js/composition-api.js

@@ -1,458 +0,0 @@
-(function(window) {
-    let currentSetupContext = null;
-
-    class SetupContext {
-        constructor(component) {
-            this.component = component;
-            this.lifecycle = (component && component.lifecycle) || null;
-            this._onMountedHandlers = [];
-            this._onUnmountedHandlers = [];
-            this._onUpdatedHandlers = [];
-            this._watches = [];
-            this._refs = new Map();
-            this._computedDeps = new Map();
-        }
-
-        ref(initialValue = null) {
-            if (window.kupolaData) {
-                const key = `__ref_${Math.random().toString(36).slice(2, 11)}__`;
-                window.kupolaData.set(key, initialValue);
-                
-                return {
-                    get value() {
-                        return window.kupolaData.get(key);
-                    },
-                    set value(newValue) {
-                        window.kupolaData.set(key, newValue);
-                    },
-                    _key: key
-                };
-            }
-
-            const refObj = {
-                _value: initialValue,
-                _subscribers: new Set()
-            };
-
-            Object.defineProperty(refObj, 'value', {
-                get() {
-                    return refObj._value;
-                },
-                set(newValue) {
-                    if (newValue !== refObj._value) {
-                        refObj._value = newValue;
-                        refObj._subscribers.forEach(sub => sub(newValue));
-                    }
-                }
-            });
-
-            return refObj;
-        }
-
-        reactive(target) {
-            if (window.kupolaData) {
-                return window.kupolaData.createReactive(target);
-            }
-
-            const self = this;
-            const handler = {
-                get(target, key) {
-                    if (key === '__isReactive') return true;
-                    if (key === '__raw') return target;
-                    const result = target[key];
-                    if (typeof result === 'object' && result !== null && !result.__isReactive) {
-                        target[key] = self.reactive(result);
-                    }
-                    return target[key];
-                },
-                set(target, key, value) {
-                    if (target[key] === value) return true;
-                    target[key] = value;
-                    self._notifyWatchers(key, value);
-                    return true;
-                },
-                deleteProperty(target, key) {
-                    delete target[key];
-                    self._notifyWatchers(key, undefined);
-                    return true;
-                }
-            };
-
-            const proxy = new Proxy(target, handler);
-            proxy.__isReactive = true;
-            return proxy;
-        }
-
-        onMounted(handler) {
-            if (this.lifecycle) {
-                this.lifecycle.on('mount', handler, { name: 'onMounted' });
-            } else {
-                this._onMountedHandlers.push(handler);
-            }
-        }
-
-        onUnmounted(handler) {
-            if (this.lifecycle) {
-                this.lifecycle.on('unmount', handler, { name: 'onUnmounted' });
-            } else {
-                this._onUnmountedHandlers.push(handler);
-            }
-        }
-
-        onUpdated(handler) {
-            if (this.lifecycle) {
-                this.lifecycle.on('update', handler, { name: 'onUpdated' });
-            } else {
-                this._onUpdatedHandlers.push(handler);
-            }
-        }
-
-        watch(source, handler, options = {}) {
-            if (typeof source === 'function') {
-                const watcher = () => {
-                    const newValue = source();
-                    if (newValue !== watcher._oldValue) {
-                        handler(newValue, watcher._oldValue);
-                        watcher._oldValue = newValue;
-                    }
-                };
-                watcher._oldValue = undefined;
-                this._watches.push(watcher);
-                watcher();
-
-                if (window.kupolaData) {
-                    const trackedPaths = [];
-                    const originalGet = window.kupolaData.get;
-                    window.kupolaData.get = function(k) {
-                        trackedPaths.push(k);
-                        return originalGet.call(this, k);
-                    };
-                    source();
-                    window.kupolaData.get = originalGet;
-                    
-                    trackedPaths.forEach(path => {
-                        window.kupolaData.observe(path, watcher);
-                    });
-                }
-            } else if (typeof source === 'object' && source !== null) {
-                if (source._subscribers) {
-                    source._subscribers.add(handler);
-                } else if (source._key && window.kupolaData) {
-                    window.kupolaData.observe(source._key, () => {
-                        handler(source.value);
-                    });
-                }
-            }
-        }
-
-        computed(getter) {
-            const result = this.ref();
-            const self = this;
-            
-            let update = () => {
-                try {
-                    result.value = getter();
-                } catch (e) {
-                    console.error('Computed property error:', e);
-                }
-            };
-
-            const trackedPaths = [];
-            if (window.kupolaData) {
-                const originalGet = window.kupolaData.get;
-                window.kupolaData.get = function(k) {
-                    trackedPaths.push(k);
-                    return originalGet.call(this, k);
-                };
-                
-                update();
-                
-                window.kupolaData.get = originalGet;
-                
-                trackedPaths.forEach(path => {
-                    window.kupolaData.observe(path, update);
-                });
-                
-                this._computedDeps.set(result, trackedPaths);
-            } else {
-                update();
-            }
-
-            let computedValue = result._value;
-            
-            Object.defineProperty(result, 'value', {
-                get: () => computedValue,
-                set: (newValue) => {
-                    console.warn('Cannot assign to a computed property');
-                }
-            });
-
-            const originalUpdate = update;
-            update = () => {
-                try {
-                    computedValue = getter();
-                } catch (e) {
-                    console.error('Computed property error:', e);
-                }
-            };
-
-            return result;
-        }
-
-        emit(eventName, data) {
-            if (this.component) {
-                this.component.$emit(eventName, data);
-            }
-        }
-
-        _notifyWatchers(key, value) {
-            this._watches.forEach(watcher => {
-                try { watcher(); } catch (e) { console.error(e); }
-            });
-        }
-
-        _executeMounted() {
-            this._onMountedHandlers.forEach(handler => {
-                try { handler(); } catch (e) { console.error(e); }
-            });
-        }
-
-        _executeUnmounted() {
-            this._onUnmountedHandlers.forEach(handler => {
-                try { handler(); } catch (e) { console.error(e); }
-            });
-        }
-
-        _executeUpdated() {
-            this._onUpdatedHandlers.forEach(handler => {
-                try { handler(); } catch (e) { console.error(e); }
-            });
-        }
-
-        destroy() {
-            this._watches.forEach(watcher => {
-                if (watcher._subscribers) {
-                    watcher._subscribers.clear();
-                }
-            });
-            this._watches = [];
-            
-            this._computedDeps.forEach((paths, result) => {
-                paths.forEach(path => {
-                    if (window.kupolaData) {
-                        window.kupolaData.unobserve(path);
-                    }
-                });
-            });
-            this._computedDeps.clear();
-            
-            this._refs.clear();
-            this._onMountedHandlers = [];
-            this._onUnmountedHandlers = [];
-            this._onUpdatedHandlers = [];
-            
-            this.component = null;
-            this.lifecycle = null;
-        }
-    }
-
-    function ref(initialValue = null) {
-        if (currentSetupContext) {
-            return currentSetupContext.ref(initialValue);
-        }
-
-        if (window.kupolaData) {
-            const key = `__ref_${Math.random().toString(36).slice(2, 11)}__`;
-            window.kupolaData.set(key, initialValue);
-
-            return {
-                get value() {
-                    return window.kupolaData.get(key);
-                },
-                set value(newValue) {
-                    window.kupolaData.set(key, newValue);
-                },
-                _key: key
-            };
-        }
-
-        const refObj = {
-            _value: initialValue,
-            _subscribers: new Set()
-        };
-
-        Object.defineProperty(refObj, 'value', {
-            get() {
-                return refObj._value;
-            },
-            set(newValue) {
-                if (newValue !== refObj._value) {
-                    refObj._value = newValue;
-                    refObj._subscribers.forEach(sub => sub(newValue));
-                }
-            }
-        });
-
-        return refObj;
-    }
-
-    function reactive(target) {
-        if (currentSetupContext) {
-            return currentSetupContext.reactive(target);
-        }
-
-        if (window.kupolaData) {
-            return window.kupolaData.createReactive(target);
-        }
-
-        const handler = {
-            get(target, key) {
-                if (key === '__isReactive') return true;
-                if (key === '__raw') return target;
-                const result = target[key];
-                if (typeof result === 'object' && result !== null && !result.__isReactive) {
-                    target[key] = new Proxy(result, handler);
-                    target[key].__isReactive = true;
-                }
-                return target[key];
-            },
-            set(target, key, value) {
-                if (target[key] === value) return true;
-                target[key] = value;
-                if (currentSetupContext) {
-                    currentSetupContext._notifyWatchers(key, value);
-                }
-                return true;
-            },
-            deleteProperty(target, key) {
-                delete target[key];
-                if (currentSetupContext) {
-                    currentSetupContext._notifyWatchers(key, undefined);
-                }
-                return true;
-            }
-        };
-
-        const proxy = new Proxy(target, handler);
-        proxy.__isReactive = true;
-        return proxy;
-    }
-
-    function onMounted(handler) {
-        if (currentSetupContext) {
-            currentSetupContext.onMounted(handler);
-        } else {
-            console.warn('onMounted called outside of setup()');
-        }
-    }
-
-    function onUnmounted(handler) {
-        if (currentSetupContext) {
-            currentSetupContext.onUnmounted(handler);
-        } else {
-            console.warn('onUnmounted called outside of setup()');
-        }
-    }
-
-    function onUpdated(handler) {
-        if (currentSetupContext) {
-            currentSetupContext.onUpdated(handler);
-        } else {
-            console.warn('onUpdated called outside of setup()');
-        }
-    }
-
-    function watch(source, handler, options = {}) {
-        if (currentSetupContext) {
-            currentSetupContext.watch(source, handler, options);
-        }
-    }
-
-    function computed(getter) {
-        if (currentSetupContext) {
-            return currentSetupContext.computed(getter);
-        }
-
-        const result = ref();
-
-        let update = () => {
-        try {
-            result.value = getter();
-        } catch (e) {
-            console.error('Computed property error:', e);
-        }
-    };
-
-    if (window.kupolaData) {
-        const trackedPaths = [];
-        const originalGet = window.kupolaData.get;
-        window.kupolaData.get = function(k) {
-            trackedPaths.push(k);
-            return originalGet.call(this, k);
-        };
-        
-        update();
-        
-        window.kupolaData.get = originalGet;
-        
-        trackedPaths.forEach(path => {
-            window.kupolaData.observe(path, update);
-        });
-    } else {
-        update();
-    }
-
-    let computedValue = result._value;
-        
-        Object.defineProperty(result, 'value', {
-            get: () => computedValue,
-            set: (newValue) => {
-                console.warn('Cannot assign to a computed property');
-            }
-        });
-
-        const originalUpdate = update;
-        update = () => {
-            try {
-                computedValue = getter();
-            } catch (e) {
-                console.error('Computed property error:', e);
-            }
-        };
-
-        return result;
-}
-
-    function setup(setupFn) {
-        if (typeof setupFn !== 'function') {
-            console.error('setup() requires a function argument');
-            return;
-        }
-
-        const setupContext = new SetupContext();
-        const prevContext = currentSetupContext;
-        currentSetupContext = setupContext;
-
-        let result;
-        try {
-            result = setupFn(setupContext);
-        } finally {
-            currentSetupContext = prevContext;
-        }
-
-        return result;
-    }
-
-    window.SetupContext = SetupContext;
-    window.ref = ref;
-    window.reactive = reactive;
-    window.onMounted = onMounted;
-    window.onUnmounted = onUnmounted;
-    window.onUpdated = onUpdated;
-    window.watch = watch;
-    window.computed = computed;
-    window.setup = setup;
-    window._getCurrentSetupContext = () => currentSetupContext;
-    window._setCurrentSetupContext = (ctx) => { currentSetupContext = ctx; };
-    window._clearSetupContext = () => { currentSetupContext = null; };
-})(window);

package/js/error-handler.js

@@ -1,181 +0,0 @@
-class KupolaErrorHandler {
-  constructor() {
-    this.handlers = new Map();
-    this.errorLog = [];
-    this.maxLogs = 100;
-    this.globalHandler = null;
-  }
-
-  init() {
-    this._installGlobalHandlers();
-  }
-
-  _installGlobalHandlers() {
-    window.addEventListener('error', (event) => {
-      this.handleError(event.error || event.message, {
-        source: event.filename,
-        line: event.lineno,
-        column: event.colno,
-        type: 'global'
-      });
-    });
-
-    window.addEventListener('unhandledrejection', (event) => {
-      this.handleError(event.reason, {
-        type: 'promise',
-        rejection: true
-      });
-    });
-  }
-
-  setGlobalHandler(handler) {
-    if (typeof handler === 'function') {
-      this.globalHandler = handler;
-    }
-  }
-
-  handleError(error, context = {}) {
-    const errorInfo = this._normalizeError(error, context);
-    
-    this._logError(errorInfo);
-    this._notifyHandlers(errorInfo);
-    
-    if (this.globalHandler) {
-      try {
-        this.globalHandler(errorInfo);
-      } catch (e) {
-        console.error('[KupolaErrorHandler] Error in global handler:', e);
-      }
-    }
-    
-    return errorInfo;
-  }
-
-  _normalizeError(error, context) {
-    const errorInfo = {
-      id: this._generateId(),
-      timestamp: Date.now(),
-      message: '',
-      stack: '',
-      type: context.type || 'unknown',
-      source: context.source || '',
-      line: context.line || 0,
-      column: context.column || 0,
-      component: context.component || '',
-      hook: context.hook || '',
-      args: context.args || [],
-      ...context
-    };
-
-    if (error instanceof Error) {
-      errorInfo.message = error.message;
-      errorInfo.stack = error.stack || '';
-      errorInfo.name = error.name;
-    } else if (typeof error === 'string') {
-      errorInfo.message = error;
-    } else if (error && typeof error === 'object') {
-      errorInfo.message = error.message || JSON.stringify(error);
-      errorInfo.stack = error.stack || '';
-      errorInfo.name = error.name || '';
-    }
-
-    return errorInfo;
-  }
-
-  _generateId() {
-    return `err-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  _logError(errorInfo) {
-    this.errorLog.unshift(errorInfo);
-    if (this.errorLog.length > this.maxLogs) {
-      this.errorLog.pop();
-    }
-    
-    console.error(`[KupolaError] [${errorInfo.type}] ${errorInfo.message}`, errorInfo);
-  }
-
-  _notifyHandlers(errorInfo) {
-    this.handlers.forEach((handler, key) => {
-      try {
-        handler(errorInfo);
-      } catch (e) {
-        console.error(`[KupolaErrorHandler] Error in handler "${key}":`, e);
-      }
-    });
-  }
-
-  on(type, handler) {
-    if (!this.handlers.has(type)) {
-      this.handlers.set(type, []);
-    }
-    this.handlers.get(type).push(handler);
-  }
-
-  off(type, handler) {
-    if (!this.handlers.has(type)) return;
-    
-    const handlers = this.handlers.get(type);
-    const index = handlers.indexOf(handler);
-    if (index > -1) {
-      handlers.splice(index, 1);
-    }
-  }
-
-  getErrorLog() {
-    return [...this.errorLog];
-  }
-
-  clearErrorLog() {
-    this.errorLog = [];
-  }
-
-  getErrorCount() {
-    return this.errorLog.length;
-  }
-
-  getErrorByType(type) {
-    return this.errorLog.filter(err => err.type === type);
-  }
-
-  captureErrors(target, methodNames) {
-    if (!target || !methodNames || !Array.isArray(methodNames)) return;
-
-    methodNames.forEach(methodName => {
-      if (typeof target[methodName] === 'function') {
-        const originalMethod = target[methodName];
-        target[methodName] = function(...args) {
-          try {
-            const result = originalMethod.apply(this, args);
-            if (result instanceof Promise) {
-              return result.catch(error => {
-                kupolaErrorHandler.handleError(error, {
-                  type: 'method',
-                  component: target.constructor?.name || '',
-                  hook: methodName,
-                  args
-                });
-                throw error;
-              });
-            }
-            return result;
-          } catch (error) {
-            kupolaErrorHandler.handleError(error, {
-              type: 'method',
-              component: target.constructor?.name || '',
-              hook: methodName,
-              args
-            });
-            throw error;
-          }
-        };
-      }
-    });
-  }
-}
-
-const kupolaErrorHandler = new KupolaErrorHandler();
-window.kupolaErrorHandler = kupolaErrorHandler;
-window.KupolaErrorHandler = KupolaErrorHandler;
-
-export default KupolaErrorHandler;