snice 1.14.3 → 2.1.0

package/components/table/snice-cell-rating.ts

@@ -0,0 +1,82 @@
+import { element, property, watch, ready, query } from 'snice';
+import css from './snice-cell.css?inline';
+import type { RatingFormat, SniceCellElement, ColumnType, ColumnAlign, ColumnDefinition } from './snice-table.types';
+import './snice-rating';
+
+@element('snice-cell-rating')
+export class SniceCellRating extends HTMLElement implements SniceCellElement {
+  @property({ reflect: true })
+  align: ColumnAlign = 'center';
+
+  @property({ reflect: true })
+  type: ColumnType = 'rating';
+
+  @property({ reflect: true })
+  value: any = 0;
+
+  @property({ type: Object })
+  column: ColumnDefinition = {
+    key: '',
+    label: '',
+    type: 'rating',
+    align: 'center'
+  };
+
+  @property({ type: Object })
+  rowData: any = null;
+
+  @query('.cell-content')
+  contentElement?: HTMLElement;
+
+  html() {
+    return `
+      <div class="cell-content cell-content--rating" part="content">
+        <!-- Rating component will be created here -->
+      </div>
+    `;
+  }
+
+  css() {
+    return css;
+  }
+
+  @ready()
+  init() {
+    this.applyAlignment();
+    this.createRatingElement();
+  }
+
+  private applyAlignment() {
+    this.style.textAlign = this.align;
+  }
+
+  @watch('align')
+  updateAlignment() {
+    this.applyAlignment();
+  }
+
+  @watch('value', 'column')
+  updateContent() {
+    this.createRatingElement();
+  }
+
+  private createRatingElement() {
+    if (!this.contentElement) return;
+    
+    // Clear existing content
+    this.contentElement.innerHTML = '';
+    
+    // Create rating element
+    const rating = document.createElement('snice-rating') as any;
+    rating.value = Number(this.value) || 0;
+    
+    // Apply format from column
+    const format: RatingFormat = this.column.ratingFormat || {};
+    rating.max = format.max ?? 5;
+    rating.symbol = format.symbol ?? '★';
+    rating.emptySymbol = format.emptySymbol ?? '☆';
+    rating.color = format.color ?? '#facc15';
+    
+    this.contentElement.appendChild(rating);
+  }
+}

package/components/table/snice-cell-sparkline.ts

@@ -0,0 +1,253 @@
+import { element, property, watch, ready, query, SimpleArray } from 'snice';
+import css from './snice-cell.css?inline';
+import type { SparklineFormat, SniceCellElement, ColumnType, ColumnAlign, ColumnDefinition } from './snice-table.types';
+
+@element('snice-cell-sparkline')
+export class SniceCellSparkline extends HTMLElement implements SniceCellElement {
+  @property({ reflect: true })
+  align: ColumnAlign = 'left';
+
+  @property({ reflect: true })
+  type: ColumnType = 'sparkline';
+
+  @property({ reflect: true })
+  value: any = '';
+
+  @property({ type: Object })
+  column: ColumnDefinition = {
+    key: '',
+    label: '',
+    type: 'sparkline',
+    align: 'left'
+  };
+
+  @property({ type: Object })
+  rowData: any = null;
+
+  @query('.cell-content')
+  contentElement?: HTMLElement;
+  
+  @property({ reflect: true, attribute: 'chart-type' })
+  chartType: 'line' | 'bar' | 'area' = 'line';
+
+  @property({ reflect: true })
+  color: string = 'var(--snice-color-primary)';
+
+  @property({ type: Number, reflect: true })
+  width: number = 80;
+
+  @property({ type: Number, reflect: true })
+  height: number = 24;
+
+  @property({ type: Boolean, reflect: true, attribute: 'show-dots' })
+  showDots: boolean = false;
+
+  @property({ type: Boolean, reflect: true, attribute: 'show-baseline' })
+  showBaseline: boolean = false;
+
+  @property({ type: Number, reflect: true, attribute: 'stroke-width' })
+  strokeWidth: number = 1.5;
+
+  @property({ type: Number, reflect: true, attribute: 'min-value' })
+  minValue?: number;
+
+  @property({ type: Number, reflect: true, attribute: 'max-value' })
+  maxValue?: number;
+
+  @property({ type: SimpleArray, reflect: true })
+  data: number[] = [];
+
+  html() {
+    return `
+      <div class="cell-content cell-content--sparkline" part="content">
+        ${this.renderSparkline()}
+      </div>
+    `;
+  }
+
+  css() {
+    return css;
+  }
+
+  @ready()
+  init() {
+    this.applyAlignment();
+    this.updateSparkline();
+  }
+
+  private applyAlignment() {
+    this.style.textAlign = this.align;
+  }
+
+  @watch('align')
+  updateAlignment() {
+    this.applyAlignment();
+  }
+
+  @watch('value', 'data', 'column')
+  updateContent() {
+    if (this.contentElement) {
+      this.contentElement.innerHTML = this.renderSparkline();
+    }
+  }
+
+  @watch('value', 'data', 'chartType', 'color', 'width', 'height', 'showDots', 'showBaseline', 'strokeWidth', 'minValue', 'maxValue')
+  updateSparkline() {
+    if (this.contentElement) {
+      this.contentElement.innerHTML = this.renderSparkline();
+    }
+  }
+
+  private renderSparkline(): string {
+    if ((this.value === null || this.value === undefined) && (!this.data || this.data.length === 0)) {
+      return '';
+    }
+
+    // Use custom formatter if provided
+    if (this.column.formatter) {
+      return this.column.formatter(this.value, this.rowData);
+    }
+
+    const data = this.parseData();
+    if (data.length === 0) {
+      return '<span style="color: #6c757d; font-style: italic;">No data</span>';
+    }
+
+    // Use column sparkline format or component properties
+    const format: SparklineFormat = this.column.sparklineFormat || {
+      type: this.chartType,
+      color: this.color,
+      width: this.width,
+      height: this.height
+    };
+
+    const width = format.width ?? this.width;
+    const height = format.height ?? this.height;
+    const color = format.color ?? this.color;
+    const type = format.type ?? this.chartType;
+
+    return this.createCanvas(data, width, height, color, type);
+  }
+
+  private parseData(): number[] {
+    // First, try the dedicated data property (using SimpleArray)
+    if (this.data && Array.isArray(this.data) && this.data.length > 0) {
+      return this.data.map(v => Number(v)).filter(n => !isNaN(n));
+    }
+
+    // Fallback to value property for backwards compatibility
+    if (Array.isArray(this.value)) {
+      return this.value.map(v => Number(v)).filter(n => !isNaN(n));
+    }
+    
+    if (typeof this.value === 'string') {
+      // Try to parse as JSON array first (e.g., "[1,2,3]")
+      if (this.value.startsWith('[') && this.value.endsWith(']')) {
+        try {
+          const parsed = JSON.parse(this.value);
+          if (Array.isArray(parsed)) {
+            return parsed.map(v => Number(v)).filter(n => !isNaN(n));
+          }
+        } catch {
+          // Fall through to comma-separated parsing
+        }
+      }
+      
+      // Try to parse comma-separated values
+      try {
+        return this.value.split(',').map(v => Number(v.trim())).filter(n => !isNaN(n));
+      } catch {
+        return [];
+      }
+    }
+
+    return [];
+  }
+
+  private createCanvas(data: number[], width: number, height: number, color: string, type: string): string {
+    if (data.length === 0) return '';
+
+    // Create a canvas element
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    
+    if (!ctx) return '<div style="color: red;">Canvas not supported</div>';
+
+    const padding = 2;
+    const chartWidth = width - (padding * 2);
+    const chartHeight = height - (padding * 2);
+
+    const min = this.minValue ?? Math.min(...data);
+    const max = this.maxValue ?? Math.max(...data);
+    const range = max - min || 1;
+
+    // Clear canvas
+    ctx.clearRect(0, 0, width, height);
+    
+    // Set color and line properties
+    ctx.strokeStyle = color;
+    ctx.fillStyle = color;
+    ctx.lineWidth = this.strokeWidth;
+    ctx.lineCap = 'round';
+    ctx.lineJoin = 'round';
+
+    if (type === 'line' || type === 'area') {
+      const points = data.map((val, i) => {
+        const x = padding + (i / (data.length - 1)) * chartWidth;
+        const y = padding + chartHeight - ((val - min) / range) * chartHeight;
+        return [x, y];
+      });
+
+      // Draw area fill if needed
+      if (type === 'area') {
+        ctx.beginPath();
+        ctx.moveTo(points[0][0], points[0][1]);
+        points.forEach(([x, y]) => ctx.lineTo(x, y));
+        ctx.lineTo(points[points.length - 1][0], height - padding);
+        ctx.lineTo(points[0][0], height - padding);
+        ctx.closePath();
+        ctx.globalAlpha = 0.3;
+        ctx.fill();
+        ctx.globalAlpha = 1;
+      }
+
+      // Draw line
+      ctx.beginPath();
+      ctx.moveTo(points[0][0], points[0][1]);
+      points.forEach(([x, y]) => ctx.lineTo(x, y));
+      ctx.stroke();
+
+      // Draw dots if enabled
+      if (this.showDots) {
+        points.forEach(([x, y]) => {
+          ctx.beginPath();
+          ctx.arc(x, y, 1.5, 0, 2 * Math.PI);
+          ctx.fill();
+        });
+      }
+
+    } else if (type === 'bar') {
+      const barWidth = (chartWidth / data.length) * 0.8;
+      const barSpacing = (chartWidth / data.length) * 0.2;
+
+      data.forEach((val, i) => {
+        const barHeight = ((val - min) / range) * chartHeight;
+        const x = padding + i * (barWidth + barSpacing);
+        const y = padding + chartHeight - barHeight;
+        
+        ctx.fillRect(x, y, barWidth, barHeight);
+      });
+    }
+
+    // Convert canvas to data URL
+    try {
+      const dataUrl = canvas.toDataURL('image/png');
+      return `<img src="${dataUrl}" width="${width}" height="${height}" alt="Sparkline chart" style="display: block; vertical-align: middle;">`;
+    } catch (error) {
+      console.error('Error creating canvas image:', error);
+      return `<div style="color: red;">Canvas error</div>`;
+    }
+  }
+}

package/components/table/snice-cell-text.ts

@@ -0,0 +1,125 @@
+import { element, property, watch, ready, query } from 'snice';
+import css from './snice-cell.css?inline';
+import type { SniceCellElement, ColumnType, ColumnAlign, ColumnDefinition } from './snice-table.types';
+
+@element('snice-cell-text')
+export class SniceCellText extends HTMLElement implements SniceCellElement {
+  @property({ reflect: true })
+  align: ColumnAlign = 'left';
+
+  @property({ reflect: true })
+  type: ColumnType = 'text';
+
+  @property({ reflect: true })
+  value: any = '';
+
+  @property({ type: Object })
+  column: ColumnDefinition = {
+    key: '',
+    label: '',
+    type: 'text',
+    align: 'left'
+  };
+
+  @property({ type: Object })
+  rowData: any = null;
+
+  @query('.cell-content')
+  contentElement?: HTMLElement;
+  
+  @property({ type: Boolean, reflect: true })
+  multiline: boolean = false;
+
+  @property({ type: Number, attribute: 'max-lines' })
+  maxLines?: number;
+
+  html() {
+    const content = this.formatTextContent();
+    const styles = this.getTextStyles();
+    
+    return `
+      <div class="cell-content cell-content--text" part="content" style="${styles}">
+        ${content}
+      </div>
+    `;
+  }
+
+  css() {
+    return css;
+  }
+
+  @ready()
+  init() {
+    this.applyAlignment();
+  }
+
+  private applyAlignment() {
+    this.style.textAlign = this.align;
+  }
+
+  @watch('align')
+  updateAlignment() {
+    this.applyAlignment();
+  }
+
+  @watch('value', 'column')
+  updateContent() {
+    if (this.contentElement) {
+      const content = this.formatTextContent();
+      const styles = this.getTextStyles();
+      this.contentElement.innerHTML = content;
+      this.contentElement.setAttribute('style', styles);
+    }
+  }
+
+  private formatTextContent(): string {
+    if (this.value === null || this.value === undefined) {
+      return '';
+    }
+
+    let text = String(this.value);
+
+    // Apply custom formatter if provided
+    if (this.column.formatter) {
+      text = this.column.formatter(this.value, this.rowData);
+    }
+
+    // Handle multiline text
+    if (this.multiline) {
+      text = text.replace(/\n/g, '<br>');
+    }
+
+    // Handle ellipsis for single line
+    if (!this.multiline && this.column.ellipsis) {
+      // CSS will handle the ellipsis
+    }
+
+    return text;
+  }
+
+  private getTextStyles(): string {
+    let styles = [];
+
+    if (!this.multiline) {
+      styles.push('white-space: nowrap');
+      if (this.column.ellipsis) {
+        styles.push('overflow: hidden');
+        styles.push('text-overflow: ellipsis');
+      }
+    } else {
+      if (this.column.wrap) {
+        styles.push('white-space: pre-wrap');
+        styles.push('word-wrap: break-word');
+      }
+      
+      if (this.maxLines) {
+        styles.push('display: -webkit-box');
+        styles.push('-webkit-box-orient: vertical');
+        styles.push(`-webkit-line-clamp: ${this.maxLines}`);
+        styles.push('overflow: hidden');
+      }
+    }
+
+    return styles.join('; ');
+  }
+}