@aquera/nile-elements 0.0.80 → 0.0.81

package/package.json

@@ -3,7 +3,7 @@
   "description": "Webcomponent nile-elements following open-wc recommendations",
   "license": "MIT",
   "author": "nile-elements",
-  "version": "0.0.80",
+  "version": "0.0.81",
   "main": "dist/src/index.js",
   "type": "module",
   "module": "dist/src/index.js",

package/src/index.ts

@@ -63,4 +63,5 @@ export { NileStepperItem } from './nile-stepper-item';
 export { NileStepper } from './nile-stepper';
 export { NileHeroHeader } from './nile-hero-header';
 export { NileVerticalStepperItem } from './nile-vertical-stepper-item';
-export { NileFormatDate } from './nile-format-date';
+export { NileFormatDate } from './nile-format-date';
+export { NileSplitPanel } from './nile-split-panel';

package/src/internal/drag.ts

@@ -0,0 +1,45 @@
+interface DragOptions {
+  /** Callback that runs as dragging occurs. */
+  onMove: (x: number, y: number) => void;
+  /** Callback that runs when dragging stops. */
+  onStop: () => void;
+  /**
+   * When an initial event is passed, the first drag will be triggered immediately using the coordinates therein. This
+   * is useful when the drag is initiated by a mousedown/touchstart event but you want the initial "click" to activate
+   * a drag (e.g. positioning a handle initially at the click target).
+   */
+  initialEvent: PointerEvent;
+}
+
+/** Begins listening for dragging. */
+export function drag(container: HTMLElement, options?: Partial<DragOptions>) {
+  function move(pointerEvent: PointerEvent) {
+    const dims = container.getBoundingClientRect();
+    const defaultView = container.ownerDocument.defaultView!;
+    const offsetX = dims.left + defaultView.pageXOffset;
+    const offsetY = dims.top + defaultView.pageYOffset;
+    const x = pointerEvent.pageX - offsetX;
+    const y = pointerEvent.pageY - offsetY;
+
+    if (options?.onMove) {
+      options.onMove(x, y);
+    }
+  }
+
+  function stop() {
+    document.removeEventListener('pointermove', move);
+    document.removeEventListener('pointerup', stop);
+
+    if (options?.onStop) {
+      options.onStop();
+    }
+  }
+
+  document.addEventListener('pointermove', move, { passive: true });
+  document.addEventListener('pointerup', stop);
+
+  // If an initial event is set, trigger the first drag immediately
+  if (options?.initialEvent instanceof PointerEvent) {
+    move(options.initialEvent);
+  }
+}

package/src/internal/math.ts

@@ -0,0 +1,14 @@
+/** Ensures a number stays within a minimum and maximum value */
+export function clamp(value: number, min: number, max: number) {
+  const noNegativeZero = (n: number) => (Object.is(n, -0) ? 0 : n);
+
+  if (value < min) {
+    return noNegativeZero(min);
+  }
+
+  if (value > max) {
+    return noNegativeZero(max);
+  }
+
+  return noNegativeZero(value);
+}

package/src/nile-empty-state/nile-empty-state.test.ts

@@ -0,0 +1,69 @@
+import { fixture,html,expect } from "@open-wc/testing";
+import './nile-empty-state';
+import { NileEmptyState } from "./nile-empty-state";
+
+describe('NileEmptyState',()=>{
+    it('renders correctly with default properties',async ()=>{
+        const el=await fixture<NileEmptyState>(html`<nile-empty-state></nile-empty-state>`)
+        expect(el.size).to.equal('md');
+        expect(el.variant).to.equal('tonal');
+        expect(el.icon).to.equal('error');
+        expect(el.grayscale).to.be.false;
+        expect(el.text).to.equal('Empty State');
+        expect(el.subText).to.equal('No Data');
+    })
+
+    it('should reflect properties to attributes', async () => {
+        const iconName="action"
+        const el = await fixture<NileEmptyState>(html`
+          <nile-empty-state size="sm" variant="flat" icon=${iconName} grayscale text="Test state text" sub-text="Test sub text"></nile-empty-state>
+        `);
+        expect(el.getAttribute('size')).to.equal('sm');
+        expect(el.getAttribute('variant')).to.equal('flat');
+        expect(el.getAttribute('icon')).to.equal(iconName);
+        expect(el.hasAttribute('grayscale')).to.be.true;
+        expect(el.getAttribute('text')).to.equal('Test state text');
+        expect(el.getAttribute('sub-text')).to.equal('Test sub text');
+      });
+
+      it('should render different sizes correctly', async () => {
+        const sizes:Array<'sm' | 'md' | 'lg' >= ['sm', 'md', 'lg'];
+        for (const size of sizes) {
+          const el = await fixture<NileEmptyState>(html`<nile-empty-state size="${size}"></nile-empty-state>`);
+          const container = el.shadowRoot!.querySelector('.empty-state')!;
+          expect(container.classList.contains(`empty-state--${size}`)).to.be.true;
+        }
+      });
+
+      it('should render different variants correctly', async () => {
+        const variants :Array<'flat' | 'content' | 'tonal' >= ['flat', 'content', 'tonal'];
+        for (const variant of variants) {
+          const el = await fixture<NileEmptyState>(html`<nile-empty-state variant="${variant}"></nile-empty-state>`);
+          const container = el.shadowRoot!.querySelector(`.empty-state__body--${variant}`)!;
+          expect(container).to.exist;
+        }
+      });
+
+      it('should render text properties correctly', async () => {
+        const sampleText='Custom Text'
+        const sampleSubText="Custom SubText"
+        const el = await fixture<NileEmptyState>(html`
+          <nile-empty-state text=${sampleText} sub-text=${sampleSubText}></nile-empty-state>
+        `);
+        const textEl = el.shadowRoot!.querySelector('.empty-state__text')!;
+        const subTextEl = el.shadowRoot!.querySelector('.empty-state__subtext')!;
+        expect(textEl.textContent).to.equal(sampleText);
+        expect(subTextEl.textContent).to.equal(sampleSubText);
+      });
+
+      it('should render slot content', async () => {
+        const el = await fixture<NileEmptyState>(html`
+          <nile-empty-state>
+            <div class="slot-content">Slot Content</div>
+          </nile-empty-state>
+        `);
+        const slotContent = el.querySelector('.slot-content')!;
+        expect(slotContent).to.exist;
+        expect(slotContent.textContent).to.equal('Slot Content');
+      });
+})

package/src/nile-hero/nile-hero.test.ts

@@ -0,0 +1,45 @@
+import { fixture, html, expect, oneEvent } from '@open-wc/testing';
+import './nile-hero';
+import { NileHero } from './nile-hero';
+
+describe('NileHero', () => {
+  it('renders correctly with default properties', async () => {
+    const el = await fixture<NileHero>(html`
+		<nile-hero icon="error" hero-text="Test Hero">
+            <nile-page-header
+                heading="I am heading"
+                sub-heading="I am subheading"
+            ></nile-page-header>
+        </nile-hero>`);
+    expect(el.getAttribute('icon')).to.equal('error');
+    expect(el.hasAttribute('collapse')).to.be.false;
+    expect(el.getAttribute('img-src')).to.equal('');
+    expect(el.getAttribute('hero-text')).to.equal('Test Hero');
+    expect(el).shadowDom.to.equalSnapshot();
+  });
+
+  it('checks for collapsed state', async () => {
+    const el = await fixture<NileHero>(html`<nile-hero></nile-hero>`);
+    el.collapse = true;
+    await el.updateComplete;
+    expect(el.collapse).to.be.true;
+    el.collapse=true;
+    await el.updateComplete;
+    const heroContainer=el.shadowRoot?.querySelector('.hero__container');
+    expect(heroContainer?.classList.contains('hero__container--collapsed')).to.be.true;
+  });
+
+  it('should render slot content', async () => {
+    const el = await fixture<NileHero>(html`
+      <nile-hero>
+            <nile-page-header
+                heading="I am heading"
+                sub-heading="I am subheading"
+            ></nile-page-header>
+      </nile-hero>
+    `);
+    await el.updateComplete;
+    const NilePageHeader = el.querySelector('nile-page-header')!;
+    expect(NilePageHeader).to.exist;
+  });
+})

package/src/nile-split-panel/index.ts

@@ -0,0 +1 @@
+export { NileSplitPanel } from './nile-split-panel';

package/src/nile-split-panel/nile-split-panel.css.ts

@@ -0,0 +1,101 @@
+/**
+* Copyright Aquera Inc 2023
+*
+* This source code is licensed under the BSD-3-Clause license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+import {css} from 'lit-element';
+
+/**
+ * SplitPanel CSS
+ */
+export const styles = css`
+  :host *,
+  :host *::before,
+  :host *::after {
+    box-sizing: inherit;
+  }
+
+  [hidden] {
+    display: none !important;
+  }
+
+  :host {
+    box-sizing: border-box;
+    --divider-width: 4px;
+    --divider-hit-area: 12px;
+    --min: 0%;
+    --max: 100%;
+
+    display: grid;
+  }
+
+  .start,
+  .end {
+    overflow: hidden;
+  }
+
+  .divider {
+    flex: 0 0 var(--divider-width);
+    display: flex;
+    position: relative;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--nile-colors-neutral-100);
+    color: var(--nile-colors-dark-900);
+    z-index: 1;
+  }
+
+  .divider:focus {
+    outline: none;
+  }
+
+  :host(:not([disabled])) .divider:focus-visible {
+    background-color: var(--nile-colors-blue-500);
+    color: var(--nile-colors-white-base);
+  }
+
+  :host([disabled]) .divider {
+    cursor: not-allowed;
+  }
+
+  /* Horizontal */
+  :host(:not([vertical], [disabled])) .divider {
+    cursor: col-resize;
+  }
+
+  :host(:not([vertical])) .divider::after {
+    display: flex;
+    content: '';
+    position: absolute;
+    height: 100%;
+    left: calc(var(--divider-hit-area) / -2 + var(--divider-width) / 2);
+    width: var(--divider-hit-area);
+  }
+
+  /* Vertical */
+  :host([vertical]) {
+    flex-direction: column;
+  }
+
+  :host([vertical]:not([disabled])) .divider {
+    cursor: row-resize;
+  }
+
+  :host([vertical]) .divider::after {
+    content: '';
+    position: absolute;
+    width: 100%;
+    top: calc(var(--divider-hit-area) / -2 + var(--divider-width) / 2);
+    height: var(--divider-hit-area);
+  }
+
+  @media (forced-colors: active) {
+    .divider {
+      outline: solid 1px transparent;
+    }
+  }
+`;
+
+export default [styles];

package/src/nile-split-panel/nile-split-panel.ts

@@ -0,0 +1,285 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {LitElement, CSSResultArray, TemplateResult} from 'lit-element';
+import {styles} from './nile-split-panel.css';
+import NileElement from '../internal/nile-element';
+
+
+import { clamp } from '../internal/math';
+import { customElement, property, query } from 'lit/decorators.js';
+import { drag } from '../internal/drag';
+import { html } from 'lit';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { watch } from '../internal/watch';
+import type { CSSResultGroup } from 'lit';
+
+/**
+ * @summary Split panels display two adjacent panels, allowing the user to reposition them.
+ *
+ * @event nile-reposition - Emitted when the divider's position changes.
+ *
+ * @slot start - Content to place in the start panel.
+ * @slot end - Content to place in the end panel.
+ * @slot divider - The divider. Useful for slotting in a custom icon that renders as a handle.
+ *
+ * @csspart start - The start panel.
+ * @csspart end - The end panel.
+ * @csspart panel - Targets both the start and end panels.
+ * @csspart divider - The divider that separates the start and end panels.
+ *
+ * @cssproperty [--divider-width=4px] - The width of the visible divider.
+ * @cssproperty [--divider-hit-area=12px] - The invisible region around the divider where dragging can occur. This is
+ *  usually wider than the divider to facilitate easier dragging.
+ * @cssproperty [--min=0] - The minimum allowed size of the primary panel.
+ * @cssproperty [--max=100%] - The maximum allowed size of the primary panel.
+ */
+@customElement('nile-split-panel')
+export class NileSplitPanel extends NileElement {
+
+	static styles: CSSResultGroup = styles;
+
+  private cachedPositionInPixels: number;
+  private resizeObserver: ResizeObserver;
+  private size: number;
+
+  @query('.divider') divider: HTMLElement;
+
+  /**
+   * The current position of the divider from the primary panel's edge as a percentage 0-100. Defaults to 50% of the
+   * container's initial size.
+   */
+  @property({ type: Number, reflect: true }) position = 50;
+
+  /** The current position of the divider from the primary panel's edge in pixels. */
+  @property({ attribute: 'position-in-pixels', type: Number }) positionInPixels: number;
+
+  /** Draws the split panel in a vertical orientation with the start and end panels stacked. */
+  @property({ type: Boolean, reflect: true }) vertical = false;
+
+  /** Disables resizing. Note that the position may still change as a result of resizing the host element. */
+  @property({ type: Boolean, reflect: true }) disabled = false;
+
+  /**
+   * If no primary panel is designated, both panels will resize proportionally when the host element is resized. If a
+   * primary panel is designated, it will maintain its size and the other panel will grow or shrink as needed when the
+   * host element is resized.
+   */
+  @property() primary?: 'start' | 'end';
+
+  /**
+   * One or more space-separated values at which the divider should snap. Values can be in pixels or percentages, e.g.
+   * `"100px 50%"`.
+   */
+  @property() snap?: string;
+
+  /** How close the divider must be to a snap point until snapping occurs. */
+  @property({ type: Number, attribute: 'snap-threshold' }) snapThreshold = 12;
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.resizeObserver = new ResizeObserver(entries => this.handleResize(entries));
+    this.updateComplete.then(() => this.resizeObserver.observe(this));
+
+    this.detectSize();
+    this.cachedPositionInPixels = this.percentageToPixels(this.position);
+  }
+
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.resizeObserver.unobserve(this);
+  }
+
+  private detectSize() {
+    const { width, height } = this.getBoundingClientRect();
+    this.size = this.vertical ? height : width;
+  }
+
+  private percentageToPixels(value: number) {
+    return this.size * (value / 100);
+  }
+
+  private pixelsToPercentage(value: number) {
+    return (value / this.size) * 100;
+  }
+
+  private handleDrag(event: PointerEvent) {
+    const isRtl = false;
+
+    if (this.disabled) {
+      return;
+    }
+
+    // Prevent text selection when dragging
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+
+    drag(this, {
+      onMove: (x, y) => {
+        let newPositionInPixels = this.vertical ? y : x;
+
+        // Flip for end panels
+        if (this.primary === 'end') {
+          newPositionInPixels = this.size - newPositionInPixels;
+        }
+
+        // Check snap points
+        if (this.snap) {
+          const snaps = this.snap.split(' ');
+
+          snaps.forEach(value => {
+            let snapPoint: number;
+
+            if (value.endsWith('%')) {
+              snapPoint = this.size * (parseFloat(value) / 100);
+            } else {
+              snapPoint = parseFloat(value);
+            }
+
+            if (isRtl && !this.vertical) {
+              snapPoint = this.size - snapPoint;
+            }
+
+            if (
+              newPositionInPixels >= snapPoint - this.snapThreshold &&
+              newPositionInPixels <= snapPoint + this.snapThreshold
+            ) {
+              newPositionInPixels = snapPoint;
+            }
+          });
+        }
+
+        this.position = clamp(this.pixelsToPercentage(newPositionInPixels), 0, 100);
+      },
+      initialEvent: event
+    });
+  }
+
+  private handleKeyDown(event: KeyboardEvent) {
+    if (this.disabled) {
+      return;
+    }
+
+    if (['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End'].includes(event.key)) {
+      let newPosition = this.position;
+      const incr = (event.shiftKey ? 10 : 1) * (this.primary === 'end' ? -1 : 1);
+
+      event.preventDefault();
+
+      if ((event.key === 'ArrowLeft' && !this.vertical) || (event.key === 'ArrowUp' && this.vertical)) {
+        newPosition -= incr;
+      }
+
+      if ((event.key === 'ArrowRight' && !this.vertical) || (event.key === 'ArrowDown' && this.vertical)) {
+        newPosition += incr;
+      }
+
+      if (event.key === 'Home') {
+        newPosition = this.primary === 'end' ? 100 : 0;
+      }
+
+      if (event.key === 'End') {
+        newPosition = this.primary === 'end' ? 0 : 100;
+      }
+
+      this.position = clamp(newPosition, 0, 100);
+    }
+  }
+
+  private handleResize(entries: ResizeObserverEntry[]) {
+    const { width, height } = entries[0].contentRect;
+    this.size = this.vertical ? height : width;
+
+    // Resize when a primary panel is set
+    if (this.primary) {
+      this.position = this.pixelsToPercentage(this.cachedPositionInPixels);
+    }
+  }
+
+  @watch('position')
+  handlePositionChange() {
+    this.cachedPositionInPixels = this.percentageToPixels(this.position);
+    this.positionInPixels = this.percentageToPixels(this.position);
+    this.emit('nile-reposition');
+  }
+
+  @watch('positionInPixels')
+  handlePositionInPixelsChange() {
+    this.position = this.pixelsToPercentage(this.positionInPixels);
+  }
+
+  @watch('vertical')
+  handleVerticalChange() {
+    this.detectSize();
+  }
+
+  render() {
+    const gridTemplate = this.vertical ? 'gridTemplateRows' : 'gridTemplateColumns';
+    const gridTemplateAlt = this.vertical ? 'gridTemplateColumns' : 'gridTemplateRows';
+    const isRtl = false;
+    const primary = `
+      clamp(
+        0%,
+        clamp(
+          var(--min),
+          ${this.position}% - var(--divider-width) / 2,
+          var(--max)
+        ),
+        calc(100% - var(--divider-width))
+      )
+    `;
+    const secondary = 'auto';
+
+    if (this.primary === 'end') {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      } else {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      }
+    } else {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      } else {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      }
+    }
+
+    // Unset the alt grid template property
+    this.style[gridTemplateAlt] = '';
+
+    return html`
+      <slot name="start" part="panel start" class="start"></slot>
+
+      <div
+        part="divider"
+        class="divider"
+        tabindex=${ifDefined(this.disabled ? undefined : '0')}
+        role="separator"
+        aria-valuenow=${this.position}
+        aria-valuemin="0"
+        aria-valuemax="100"
+        aria-label="resize"
+        @keydown=${this.handleKeyDown}
+        @mousedown=${this.handleDrag}
+        @touchstart=${this.handleDrag}
+      >
+        <slot name="divider"></slot>
+      </div>
+
+      <slot name="end" part="panel end" class="end"></slot>
+    `;
+  }
+}
+
+export default NileSplitPanel;
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'nile-split-panel': NileSplitPanel;
+  }
+}