codanna 0.9.19

Code Intelligence for Large Language Models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

import { EventEmitter } from './EventEmitter.js';

/**
 * Base component class for vanilla JS components
 * Provides lifecycle methods and template rendering
 */
export class Component extends EventEmitter {
  constructor(element, options = {}) {
    super();
    this.element = typeof element === 'string'
      ? document.querySelector(element)
      : element;

    if (!this.element) {
      throw new Error('Component element not found');
    }

    this.state = options.state || {};
    this.props = options.props || {};
    this.children = new Map();

    this.init();
  }

  init() {
    // Override in subclass
  }

  setState(partial) {
    const prevState = { ...this.state };
    this.state = { ...this.state, ...partial };

    if (this.shouldUpdate(prevState, this.state)) {
      this.update();
      this.emit('statechange', this.state, prevState);
    }
  }

  shouldUpdate(prevState, nextState) {
    return JSON.stringify(prevState) !== JSON.stringify(nextState);
  }

  render() {
    // Override in subclass - return HTML string
    return '';
  }

  update() {
    const html = this.render();
    this.element.innerHTML = html;
    this.afterUpdate();
  }

  afterUpdate() {
    // Override in subclass - bind events, etc.
  }

  mount(container) {
    const parent = typeof container === 'string'
      ? document.querySelector(container)
      : container;

    if (parent) {
      parent.appendChild(this.element);
      this.update();
      this.emit('mount');
    }
    return this;
  }

  unmount() {
    this.emit('beforeunmount');
    this.children.forEach((child) => child.unmount());
    this.children.clear();
    this.element.remove();
    this.removeAllListeners();
    this.emit('unmount');
  }

  addChild(key, child) {
    this.children.set(key, child);
    return child;
  }

  getChild(key) {
    return this.children.get(key);
  }

  removeChild(key) {
    const child = this.children.get(key);
    if (child) {
      child.unmount();
      this.children.delete(key);
    }
  }

  $(selector) {
    return this.element.querySelector(selector);
  }

  $$(selector) {
    return Array.from(this.element.querySelectorAll(selector));
  }

  delegate(eventType, selector, handler) {
    this.element.addEventListener(eventType, (event) => {
      const target = event.target.closest(selector);
      if (target && this.element.contains(target)) {
        handler.call(target, event, target);
      }
    });
  }
}

export default Component;