mtrl-addons 0.1.2 → 0.2.2

package/src/styles/components/_vlist.scss

@@ -0,0 +1,352 @@
+// src/styles/components/_vlist.scss
+@use "../../../../mtrl/src/styles/abstract/base" as base;
+@use "../../../../mtrl/src/styles/abstract/variables" as v;
+@use "../../../../mtrl/src/styles/abstract/functions" as f;
+@use "../../../../mtrl/src/styles/abstract/mixins" as m;
+@use "../../../../mtrl/src/styles/abstract/theme" as t;
+
+// ===========================
+// Variables & Configuration
+// ===========================
+
+// Component prefixes
+$prefix: base.$prefix;
+$component: "#{$prefix}-vlist";
+$viewport: "#{$prefix}-viewport";
+$viewport-item: "#{$prefix}-viewport-item";
+
+// Transitions
+$transition-duration: v.motion("duration-medium1");
+$transition-easing: v.motion("easing-standard");
+
+// Common transitions
+$color-transition: color $transition-duration $transition-easing;
+$bg-transition: background-color $transition-duration $transition-easing;
+$opacity-transition: opacity $transition-duration $transition-easing;
+
+// ===========================
+// Animations
+// ===========================
+
+@keyframes placeholder-pulse {
+    0%,
+    100% {
+        opacity: 0.6;
+    }
+    50% {
+        opacity: 0.4;
+    }
+}
+
+@keyframes fade-in {
+    from {
+        opacity: 0.6;
+    }
+    to {
+        opacity: 1;
+    }
+}
+
+@keyframes item-updated {
+    0% {
+        background-color: t.alpha("primary", 0.25);
+        box-shadow: inset 0 0 0 2px t.alpha("primary", 0.4);
+    }
+    100% {
+        background-color: transparent;
+        box-shadow: inset 0 0 0 2px transparent;
+    }
+}
+
+// ===========================
+// Main VList Container
+// ===========================
+
+.#{$component} {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    min-height: 100px;
+    background-color: t.color("surface");
+    border: 2px solid var(--mtrl-sys-color-outline-variant);
+    border-radius: 3px;
+    transition: $bg-transition;
+
+    // Performance optimizations
+    contain: layout style paint;
+    transform: translateZ(0);
+    backface-visibility: hidden;
+
+    // Selection mode
+    &--selection {
+        cursor: pointer;
+        .#{$viewport-item}:hover {
+            background-color: t.alpha("on-surface-variant", 0.1);
+        }
+        // Selected state
+        .#{$viewport-item}--selected,
+        .#{$viewport-item}--selected:hover {
+            background-color: t.color("secondary-container");
+            color: t.color("on-secondary-container");
+            transition: $bg-transition, $color-transition;
+
+            // // Update state layer color for selected state
+            // &::before {
+            //   background-color: t.color("on-secondary-container");
+            // }
+
+            // Update text and icon colors for selected state
+            .#{$component}-item {
+                &-leading,
+                &-trailing,
+                &-supporting,
+                &-overline,
+                &-meta {
+                    color: t.color("on-secondary-container");
+                    transition: $color-transition;
+                }
+            }
+        }
+    }
+
+    // Disabled state
+    &--disabled {
+        pointer-events: none;
+        opacity: 0.38;
+        transition: $opacity-transition;
+    }
+}
+
+// ===========================
+// Viewport Structure
+// ===========================
+
+.#{$viewport} {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+
+    // Items container
+    &-items {
+        position: relative;
+        width: 100%;
+        height: 100%;
+        padding: 8px 0;
+        will-change: transform;
+    }
+}
+
+.#{$viewport-item} {
+    user-select: none;
+    opacity: 1;
+    transition: $opacity-transition;
+    will-change: transform;
+    // Apply fade-in animation to items that replace placeholders
+    &--replaced {
+        animation: fade-in 0.3s ease-out;
+    }
+    // Apply highlight animation when item is updated
+    &--updated,
+    &--updated > * {
+        animation: item-updated 0.6s ease-out;
+    }
+
+    // Inner item update animation (applied to template's root element)
+    .item--updated {
+        animation: item-updated 0.6s ease-out;
+    }
+}
+
+.#{$viewport-item} {
+    padding: 11px 12px;
+    display: flex;
+    align-items: start;
+    transition: background-color 0.2s ease;
+    // align-items: center;
+    min-height: 48px;
+    left: 0;
+    right: 0;
+    width: 100%;
+    will-change: transform;
+    contain: layout style;
+    gap: 16px;
+    color: var(--mtrl-sys-color-on-surface);
+    overflow: hidden;
+}
+
+.#{$viewport-item}__avatar,
+.#{$viewport-item}__image {
+    width: 40px;
+    height: 40px;
+    margin-top: 4px;
+    border-radius: 50%;
+    background-color: var(--mtrl-sys-color-primary-container);
+    color: white;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: bold;
+    flex-shrink: 0;
+}
+
+.#{$viewport-item}__details {
+    flex: 1;
+    min-width: 0;
+    margin-left: 12px;
+}
+
+.#{$viewport-item}__headline {
+    font-weight: 500;
+}
+
+.#{$viewport-item}__text {
+    // color: #666;
+    font-size: 14px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.#{$viewport-item}__meta {
+    color: var(--mtrl-sys-color-on-surface-variant);
+    font-size: 12px;
+    margin-top: 2px;
+}
+
+// ===========================
+// Placeholder Styling
+// ===========================
+
+.#{$viewport-item}--placeholder {
+    opacity: 0.6; // Match the animation start/end opacity
+    animation: placeholder-pulse 2s ease-in-out infinite;
+
+    // Placeholder content blocks - style any text elements within
+    .#{$viewport-item}__headline,
+    .#{$viewport-item}__text,
+    .#{$viewport-item}__meta {
+        position: relative;
+        display: inline-block;
+        font-size: 0.8em;
+        color: transparent;
+        background-color: var(--mtrl-sys-color-on-surface);
+        border-radius: 0.1em;
+        opacity: 0.4;
+        text-decoration: none;
+        line-height: 1;
+        padding: 0 0 0.05em;
+        vertical-align: middle;
+    }
+
+    // Layout adjustments
+    .#{$viewport-item}__text,
+    .#{$viewport-item}__meta {
+        margin-top: 0.2em;
+    }
+
+    .#{$viewport-item}__meta {
+        font-size: 10px;
+    }
+
+    // User-specific placeholder elements
+    .#{$viewport-item}__user-headline,
+    .#{$viewport-item}__user-text {
+        text-transform: capitalize;
+    }
+
+    // Avatar placeholder
+    .#{$viewport-item}__avatar {
+        background-color: var(--mtrl-sys-color-primary-container);
+        color: var(--mtrl-sys-color-primary-container);
+        opacity: 1;
+    }
+}
+
+// ===========================
+// Custom Scrollbar
+// ===========================
+
+.#{$viewport}__scrollbar {
+    position: absolute;
+    top: 0;
+    right: 0;
+    width: 8px;
+    height: 100%;
+    padding: 0;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+    cursor: pointer;
+    z-index: 10;
+
+    // Visibility states
+    &--visible,
+    &--dragging,
+    &:hover {
+        opacity: 1;
+    }
+
+    &:hover {
+        background: rgba(0, 0, 0, 0.05);
+    }
+
+    // Scrollbar thumb
+    &-thumb {
+        position: absolute;
+        top: 0;
+        width: 6px;
+        padding: 1px;
+        background: rgba(0, 0, 0, 0.3);
+        border-radius: 4px;
+        will-change: transform;
+        cursor: grab;
+        transition: background 0.2s ease;
+
+        &:hover {
+            background: rgba(0, 0, 0, 0.5);
+        }
+
+        &:active,
+        &--dragging {
+            cursor: grabbing;
+            background: rgba(0, 0, 0, 0.6);
+            transition: none;
+        }
+    }
+}
+
+// ===========================
+// Dark Theme Support
+// ===========================
+
+@media (prefers-color-scheme: dark) {
+    .#{$viewport}__scrollbar {
+        background: transparent;
+
+        &-thumb {
+            background: rgba(255, 255, 255, 0.4);
+
+            &:hover {
+                background: rgba(255, 255, 255, 0.6);
+            }
+
+            &:active,
+            &--dragging {
+                background: rgba(255, 255, 255, 0.4);
+            }
+        }
+    }
+}
+
+// ===========================
+// Performance Optimizations
+// ===========================
+
+// High-density displays
+@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) {
+    .#{$viewport-item} {
+        text-rendering: optimizeLegibility;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+    }
+}

package/src/styles/index.scss

@@ -5,7 +5,7 @@
 // These styles only add truly addons-specific features that don't exist in mtrl base.
 
 // Import component styles (only addons-specific enhancements)
-@forward "./components/list";
+@forward "./components/vlist";
 
 // Future addons-specific component styles will be added here
 // @forward "./components/datagrid";      // Advanced grid functionality

package/test/components/vlist-selection.test.ts

@@ -0,0 +1,240 @@
+// test/components/vlist-selection.test.ts
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { createVList } from "../../src/components/vlist";
+import type { VListComponent } from "../../src/components/vlist/types";
+
+describe("VList Selection", () => {
+  let container: HTMLElement;
+  let vlist: VListComponent<any>;
+
+  beforeEach(() => {
+    // Create container
+    container = document.createElement("div");
+    container.style.height = "400px";
+    container.style.width = "300px";
+    document.body.appendChild(container);
+  });
+
+  afterEach(() => {
+    // Cleanup
+    if (vlist?.destroy) {
+      vlist.destroy();
+    }
+    document.body.removeChild(container);
+  });
+
+  test("should initialize without selection when not enabled", () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Selection methods should not be available
+    expect(vlist.selectItems).toBeUndefined();
+    expect(vlist.getSelectedItems).toBeUndefined();
+  });
+
+  test("should initialize with selection when enabled", () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "single",
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Selection methods should be available
+    expect(vlist.selectItems).toBeDefined();
+    expect(vlist.getSelectedItems).toBeDefined();
+    expect(vlist.clearSelection).toBeDefined();
+  });
+
+  test("should handle single selection mode", () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "single",
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Select first item
+    vlist.selectItems([0]);
+    expect(vlist.getSelectedIndices()).toEqual([0]);
+    expect(vlist.getSelectedItems()).toEqual([items[0]]);
+
+    // Select another item - should replace selection
+    vlist.selectItems([2]);
+    expect(vlist.getSelectedIndices()).toEqual([2]);
+    expect(vlist.getSelectedItems()).toEqual([items[2]]);
+  });
+
+  test("should handle multiple selection mode", () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "multiple",
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Select multiple items
+    vlist.selectItems([0, 2, 4]);
+    expect(vlist.getSelectedIndices().sort()).toEqual([0, 2, 4]);
+
+    // Deselect one item
+    vlist.deselectItems([2]);
+    expect(vlist.getSelectedIndices().sort()).toEqual([0, 4]);
+
+    // Clear selection
+    vlist.clearSelection();
+    expect(vlist.getSelectedIndices()).toEqual([]);
+  });
+
+  test("should handle click selection", async () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "single",
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Wait for render
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Find first item element
+    const firstItem = container.querySelector(
+      '[data-index="0"]'
+    ) as HTMLElement;
+    expect(firstItem).toBeTruthy();
+
+    // Click on first item
+    firstItem.click();
+
+    // Check selection
+    expect(vlist.getSelectedIndices()).toEqual([0]);
+    expect(firstItem.classList.contains("mtrl-list-item--selected")).toBe(true);
+  });
+
+  test("should emit selection events", async () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    let selectionChangeEvent: any = null;
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "single",
+        onSelectionChange: (selectedItems, selectedIndices) => {
+          selectionChangeEvent = { selectedItems, selectedIndices };
+        },
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Select an item
+    vlist.selectItems([3]);
+
+    // Check event was fired
+    expect(selectionChangeEvent).toBeTruthy();
+    expect(selectionChangeEvent.selectedIndices).toEqual([3]);
+    expect(selectionChangeEvent.selectedItems).toEqual([items[3]]);
+  });
+
+  test("should handle initial selection", () => {
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item ${i}`,
+    }));
+
+    vlist = createVList({
+      container,
+      items,
+      selection: {
+        enabled: true,
+        mode: "multiple",
+        selectedIndices: [1, 3, 5],
+      },
+      template: (item) => {
+        const div = document.createElement("div");
+        div.className = "list-item";
+        div.textContent = item.name;
+        return div;
+      },
+    });
+
+    // Check initial selection
+    expect(vlist.getSelectedIndices().sort()).toEqual([1, 3, 5]);
+  });
+});

package/test/components/vlist.test.ts

@@ -0,0 +1,63 @@
+// test/components/vlist.test.ts
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import { JSDOM } from "jsdom";
+
+// Mock DOM environment for testing
+const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>");
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.window = dom.window as any;
+global.navigator = dom.window.navigator;
+global.requestAnimationFrame = (cb: FrameRequestCallback) => {
+  setTimeout(cb, 0);
+  return 0;
+};
+
+// Import VList after DOM setup
+import { createVList } from "../../src/components/vlist";
+
+describe("VList Component", () => {
+  let container: HTMLElement;
+
+  beforeEach(() => {
+    container = document.createElement("div");
+    document.body.appendChild(container);
+  });
+
+  it("should create a VList component", () => {
+    const vlist = createVList({
+      container,
+      items: ["Item 1", "Item 2", "Item 3"],
+      template: (item) => `<div>${item}</div>`,
+    });
+
+    expect(vlist).toBeDefined();
+    expect(vlist.element).toBeDefined();
+    expect(vlist.element.tagName).toBe("DIV");
+    expect(vlist.element.className).toContain("mtrl-vlist");
+  });
+
+  it("should have viewport functionality", () => {
+    const vlist = createVList({
+      container,
+      items: Array.from({ length: 100 }, (_, i) => `Item ${i}`),
+    });
+
+    expect(vlist.viewport).toBeDefined();
+    expect(typeof vlist.viewport.scrollToIndex).toBe("function");
+    expect(typeof vlist.viewport.getVisibleRange).toBe("function");
+  });
+
+  it("should have public API methods", () => {
+    const vlist = createVList({ container });
+
+    expect(typeof vlist.setItems).toBe("function");
+    expect(typeof vlist.getItems).toBe("function");
+    expect(typeof vlist.scrollToIndex).toBe("function");
+    expect(typeof vlist.scrollToTop).toBe("function");
+    expect(typeof vlist.scrollToBottom).toBe("function");
+    expect(typeof vlist.getState).toBe("function");
+    expect(typeof vlist.destroy).toBe("function");
+  });
+});