@aquera/nile-elements 0.1.35-beta-1.0 → 0.1.35-beta-1.3

package/package.json

@@ -3,7 +3,7 @@
   "description": "Webcomponent nile-elements following open-wc recommendations",
   "license": "MIT",
   "author": "nile-elements",
-  "version": "0.1.35-beta-1.0",
+  "version": "0.1.35-beta-1.3",
   "main": "dist/src/index.js",
   "type": "module",
   "module": "dist/src/index.js",
@@ -85,7 +85,8 @@
     "./nile-toolbar": "./dist/src/nile-toolbar/index.js",
     "./nile-inline-edit": "./dist/src/nile-inline-edit/index.js",
     "./nile-tour": "./dist/src/nile-tour/index.js",
-    "./nile-table": "./dist/src/nile-table/index.js"
+    "./nile-table": "./dist/src/nile-table/index.js",
+    "./nile-filter-chip": "./dist/src/nile-filter-chip/index.js"
   },
   "scripts": {
     "analyze": "cem analyze --litelement",
@@ -189,4 +190,4 @@
       "prettier --write"
     ]
   }
-}
+}

package/src/index.ts

@@ -75,4 +75,5 @@ export { NileTitle } from './nile-title';
 export { NileSectionMessage } from './nile-section-message';
 export { NileToolbar } from './nile-toolbar';
 export { NileInlineEdit } from './nile-inline-edit';
-export { NileTable } from './nile-table';
+export { NileTable } from './nile-table';
+export { NileFilterChip } from './nile-filter-chip';

package/src/nile-error-message/nile-error-message.css.ts

@@ -16,11 +16,11 @@ export const styles = css`
 
   .nile-error-message {
     width: 100%;
+    word-break: break-all;
     font-size: var(--nile-font-size-small);
     letter-spacing: 0.2px;
     font-weight: var(--nile-font-weight-regular);
     line-height: var(--nile-font-size-small);
-    max-width: var(--nile-error-max-width, 535px);
   }
 
   .nile-error-message__error {
@@ -32,8 +32,6 @@ export const styles = css`
     color: var(--nile-colors-dark-500);
     margin-top:6px;
     line-height: 16px;
-    max-height: var(--nile-error-max-height, 48px);
-    overflow-x: auto;
   }
 
   .nile-error-message__icon {
@@ -56,7 +54,7 @@ export const styles = css`
     border: 1px solid var(--nile-colors-red-500);
     border-left: 6px solid var(--nile-colors-red-500);
     border-radius: 4px;
-    margin-top: 8px;
+    margin-top: 12px;
     padding: 12px;
     background: var(--nile-colors-neutral-100);
   }
@@ -83,10 +81,10 @@ export const styles = css`
   }
 
   .nile-error-message__response-expanded.expanded {
-    max-height: var(--nile-error-max-dialog-height, 48px);
+    max-height: 100px;
     transition: max-height 0.3s ease-in-out;
     visibility: visible;
-    padding: 8px;
+    padding: 12px;
   }
 `;
 

package/src/nile-error-message/nile-error-message.ts

@@ -32,12 +32,6 @@ export class NileErrorMessage extends LitElement {
   @property({ type: Boolean })
   isExpanded: boolean = false;
 
-  @property({ type: String }) maxWidth: string;
-
-  @property({ type: String }) maxHeight: string;
-
-  @property({ type: String }) maxDialogHeight: string;
-
   // The maximum length before truncation.
   private readonly MAX_LENGTH: number = 100;
 
@@ -52,18 +46,6 @@ export class NileErrorMessage extends LitElement {
     return this.errorResponse;
   }
 
-  updated(changedProperties: Map<string, any>) {
-    if (changedProperties.has('maxWidth')) {
-      this.style.setProperty('--nile-error-max-width', this.maxWidth);
-    }
-    if (changedProperties.has('maxHeight')) {
-      this.style.setProperty('--nile-error-max-height', this.maxHeight);
-    }
-    if (changedProperties.has('maxDialogHeight')) {
-      this.style.setProperty('--nile-error-max-dialog-height', this.maxDialogHeight);
-    }
-  }
-
   /**
    * Toggle the expanded state of the error response.
    */

package/src/nile-error-notification/nile-error-notification.css.ts

@@ -12,7 +12,7 @@ import { css } from 'lit';
  */
 export const styles = css`
   :host {
-    --indication-color: var(--nile-colors-red-700);
+    --indication-color: var(--nile-colors-red-500);
   }
 
   .nile-error-notification {

package/src/nile-filter-chip/index.ts

@@ -0,0 +1 @@
+export { NileFilterChip } from './nile-filter-chip';

package/src/nile-filter-chip/nile-filter-chip.css.ts

@@ -0,0 +1,115 @@
+/**
+* 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';
+
+/**
+ * FilterChip CSS
+ */
+
+export const styles = css`
+
+
+  .filter-chips {
+    display: flex;
+    align-items: center;
+  }
+
+
+  .chip {
+    display: inline-flex;
+    align-items: center;
+    padding: 4px 8px;
+    border: 1px solid var(--nile-filter-chip-chip-border-color-stroke);
+    border-radius: 4px;
+    font-size: 14px;
+    background-color: var(--nile-filter-chip-background-default);
+    color: var(--nile-filter-chip-text-default);
+    transition: background-color 0.2s ease-in-out, border-color 0.2s ease-in-out;
+    cursor: pointer;
+    gap: 6px;
+    /* margin-right: 6px; */
+  }
+
+  .chip:hover {
+    background-color: var(--nile-filter-chip-hover-background);
+  }
+
+  .chip:active {
+    background-color: var(--nile-filter-chip-active-background);
+    border-color: var(--nile-filter-chip-active-border-color-stroke);
+  }
+
+  .icon {
+    color: var(--nile-filter-chip-icon-color-default);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    vertical-align: middle;
+    position: relative;
+    top: 12px;
+  }
+
+  .label {
+    font-weight: 500;
+    color: var(--nile-filter-chip-label-color-default);
+  }
+
+  nile-badge::part(base) {
+    width: auto;
+    height: 14px;
+    border-radius: 100px;
+    padding: 6px;
+    gap: 10px;
+    font-size: 8px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    line-height: 1;
+  }
+
+  .chip-container {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+  }
+
+  .clear-all-container {
+    margin-left: 18px;
+    white-space: nowrap;
+    cursor: pointer;
+  }
+
+
+  .value {
+    color: var(--nile-filter-chip-values-color-default);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    max-width: 140px;
+  }
+
+  .close-icon {
+    color: var(--nile-filter-chip-close-icon-color-default);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    padding: 2px;
+    border-radius: 50%;
+    transition: background-color 0.2s;
+  }
+
+  .close-icon:hover {
+    background-color: var(--nile-filter-chip-close-icon-hover-background);
+    color: var(--nile-filter-chip-close-icon-hover-color);
+  }
+`;
+
+export default [styles];
+
+ 

package/src/nile-filter-chip/nile-filter-chip.test.ts

@@ -0,0 +1,92 @@
+import { fixture, expect, html, oneEvent } from '@open-wc/testing';
+import './nile-filter-chip';
+import { NileFilterChip } from './nile-filter-chip';
+
+describe('<nile-filter-chip>', () => {
+  afterEach(() => {
+    (NileFilterChip as any).activeChips = [];
+  });
+
+  it('registers and unregisters itself in activeChips', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip label="L" text="T"></nile-filter-chip>
+    `);
+    expect((NileFilterChip as any).activeChips).to.include(el);
+    el.remove();
+    await el.updateComplete;
+    expect((NileFilterChip as any).activeChips).to.not.include(el);
+  });
+
+  it('renders fallback label and text', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip label="MyLabel" text="MyText"></nile-filter-chip>
+    `);
+    const label = el.shadowRoot!.querySelector('.label')! as HTMLElement;
+    const value = el.shadowRoot!.querySelector('.value')! as HTMLElement;
+    expect(label.textContent).to.equal('MyLabel:');
+    expect(value.textContent!.trim()).to.equal('MyText');
+  });
+
+  it('renders slotted label and value over fallback', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip>
+        <span slot="label">SLOT-LBL</span>
+        <span slot="value">SLOT-VAL</span>
+      </nile-filter-chip>
+    `);
+    const slottedLabel = el.querySelector('[slot="label"]')! as HTMLElement;
+    const slottedValue = el.querySelector('[slot="value"]')! as HTMLElement;
+    expect(slottedLabel.textContent).to.equal('SLOT-LBL');
+    expect(slottedValue.textContent).to.equal('SLOT-VAL');
+  });
+
+  it('renders an icon when the `icon` property is set', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip icon="★" label="L" text="T"></nile-filter-chip>
+    `);
+    const iconSpan = el.shadowRoot!.querySelector('.icon')! as HTMLElement;
+    expect(iconSpan).to.exist;
+    expect(iconSpan.textContent).to.equal('★');
+  });
+
+  it('does not render a badge when viewMoreCount is zero', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip viewMoreCount="0" label="L" text="T"></nile-filter-chip>
+    `);
+    expect(el.shadowRoot!.querySelector('nile-badge')).to.be.null;
+  });
+
+  it('renders a +badge when viewMoreCount > 0', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip viewMoreCount="5" label="L" text="T"></nile-filter-chip>
+    `);
+    const badge = el.shadowRoot!.querySelector('nile-badge')! as HTMLElement;
+    expect(badge).to.exist;
+    expect(badge.textContent).to.contain('+5');
+  });
+
+
+
+  it('dispatches `nile-click` on chip click', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip label="L" text="T"></nile-filter-chip>
+    `);
+    const chip = el.shadowRoot!.querySelector('.chip')! as HTMLElement;
+    setTimeout(() => chip.click());
+    const ev = await oneEvent(el, 'nile-click');
+    expect(ev.detail).to.deep.equal({ text: 'T', viewMoreCount: 0 });
+  });
+
+  it('dispatches `nile-close` on close icon click and removes itself', async () => {
+    const el = await fixture<NileFilterChip>(html`
+      <nile-filter-chip closable viewMoreCount="2" text="TT"></nile-filter-chip>
+    `);
+    const closeIcon = el.shadowRoot!.querySelector('.close-icon')! as HTMLElement;
+    setTimeout(() => closeIcon.click());
+    const ev = await oneEvent(el, 'nile-close');
+    expect(ev.detail).to.deep.equal({ text: 'TT', viewMoreCount: 2 });
+    expect(document.body.contains(el)).to.be.false;
+  });
+
+ 
+});

package/src/nile-filter-chip/nile-filter-chip.ts

@@ -0,0 +1,125 @@
+import { LitElement, html, css, CSSResultArray, TemplateResult } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import NileElement from '../internal/nile-element';
+import { styles } from './nile-filter-chip.css';
+
+/**
+ * Nile filter-chip component.
+ *
+ * @tag nile-filter-chip
+ */
+@customElement('nile-filter-chip')
+export class NileFilterChip extends NileElement {
+  @property({ type: String }) label = '';
+  @property({ type: String }) text = '';
+  @property({ type: Number }) viewMoreCount: number = 0;
+  @property({ type: Boolean }) editable = false;
+  @property({ type: Boolean }) closable = false;
+  @property({ type: String }) icon = '';
+  @property({ type: String }) removeIcon = '';
+
+  private static activeChips: NileFilterChip[] = [];
+
+  public static get styles(): CSSResultArray {
+    return [styles];
+  }
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.registerChip();
+  }
+
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.unregisterChip();
+  }
+
+  private registerChip() {
+    NileFilterChip.activeChips.push(this);
+  }
+
+  private unregisterChip() {
+    NileFilterChip.activeChips = NileFilterChip.activeChips.filter(
+      (chip) => chip !== this
+    );
+  }
+
+  private handleClose(event: Event) {
+    event.stopPropagation();
+    this.dispatchEvent(
+      new CustomEvent('nile-close', { detail: { text: this.text, viewMoreCount: this.viewMoreCount } })
+    );
+    this.remove();
+  }
+
+  private handleClick() {
+    this.dispatchEvent(
+      new CustomEvent('nile-click', { detail: { text: this.text, viewMoreCount: this.viewMoreCount } })
+    );
+  }
+
+  private getLabelSlot(): TemplateResult {
+    return html`
+      <slot name="label">
+        <span class="label">${this.label}:</span>
+      </slot>
+    `;
+  }
+
+  private getValueSlot(): TemplateResult {
+    return html`
+      <slot name="value">
+        <span class="value">${this.text}</span>
+      </slot>
+    `;
+  }
+
+  private getviewMoreCountSlot(): TemplateResult {
+    return html`
+      <slot name="suffix">
+        ${this.viewMoreCount
+          ? html`
+              <nile-badge variant="primary" pilltype="pill-color">
+                +${this.viewMoreCount}
+              </nile-badge>
+            `
+          : html``}
+      </slot>
+    `;
+  }
+
+  private getCloseIconSlot(): TemplateResult {
+    return html`
+      ${this.closable
+        ? html`
+            <span class="close-icon" @click="${this.handleClose}">
+              <nile-icon name="${this.removeIcon || 'close'}" size="12"></nile-icon>
+            </span>
+          `
+        : html``}
+    `;
+  }
+
+  public render(): TemplateResult {
+    return html`
+      <div class="chip" @click="${this.handleClick}">
+        <slot name="icon">
+          ${this.icon ? html`<span class="icon">${this.icon}</span>` : html``}
+        </slot>
+        ${this.getLabelSlot()}
+        <slot name="content"></slot>
+        ${this.getValueSlot()}
+        ${this.getviewMoreCountSlot()}
+        ${this.getCloseIconSlot()}
+      </div>
+    `;
+  }
+}
+
+export default NileFilterChip;
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'nile-filter-chip': NileFilterChip;
+  }
+}

package/src/nile-progress-bar/nile-progress-bar.css.ts

@@ -15,7 +15,6 @@ export default css`
     display: flex;
     height: 6px;
     justify-content: space-between;
-    display: inline-block;
   }
 
   .nile-progress-bar__progress-bar li {

package/src/nile-table/nile-table.ts

@@ -74,7 +74,7 @@ export class NileTable extends NileElement {
 	handleBodyCssUpdate(){
     if (this.rows.length<2) return;
     const tableBodies = this.rows;
-		const firstEl=tableBodies[0].shadowRoot?.querySelector<HTMLDivElement>('div.base');
+		const firstEl=tableBodies[0].shadowRoot?.querySelector<HTMLDivElement>('div.base')
 		if(firstEl) {
 			firstEl.style.borderTopRightRadius="var(--nile-radius-radius-xl)";
 			firstEl.style.borderTopLeftRadius = 'var(--nile-radius-radius-xl)';
@@ -84,7 +84,7 @@ export class NileTable extends NileElement {
 		}
 		tableBodies.forEach((tb,i)=>{
 			if(i>0 && i<tableBodies.length-1){
-				const el=tb.shadowRoot?.querySelector<HTMLDivElement>('div.base');
+				const el=tb.shadowRoot?.querySelector<HTMLDivElement>('div.base')
 				if(el) {
 					el.style.borderTopRightRadius="0px";
 					el.style.borderTopLeftRadius = "0px";

package/src/nile-tooltip/nile-tooltip.css.ts

@@ -11,93 +11,60 @@ import { css } from 'lit';
  * Tooltip CSS
  */
 export const styles = css`
+  :host {
+    --max-width: 20rem;
+    --hide-delay: 0ms;
+    --show-delay: 150ms;
 
-
-:host {
-      position: relative;
-      display: inline-block;
-    }
-    .tooltip {
-      position: fixed;
-      z-index: 1000;
-      background-color: var(--nile-tooltip-color-background, #333);
-      color: var(--nile-colors-white-base, #fff);
-      padding: 6px 10px;
-      border-radius: 4px;
-      font-size: var(--nile-tooltip-font-size-sm, 14px);
-      line-height: var(--nile-tooltip-line-height-sm, 1.5);
-      opacity: 0;
-      transition: opacity 0.2s, transform 0.2s;
-      pointer-events: none;
-      white-space: normal;
-      visibility: hidden;
-      overflow: visible;
- 
-    }
-    :host([open]) .tooltip {
-      opacity: 1;
-      visibility: visible;
-      pointer-events: auto;
-    }
-    .tooltip-content {
-      overflow: auto;
-      max-width: 250px;
-      max-height: 116px;
-    }
-    .tooltip-caret {
-      position: absolute;
-      width: calc(2 * var(--caret-size, 6px));
-      height: calc(2 * var(--caret-size, 6px));
-      background-color: inherit;
-      transform: rotate(45deg);
-      z-index: -1;
-    }
-    .trigger-container {
-      display: inline-block;
-    }
- 
- 
-:host([open]) .tooltip {
-  visibility: visible;
-  pointer-events: auto;
-  animation: fadeIn 150ms forwards;
-}
-
- 
-.tooltip.hide {
-  animation: fadeOut 100ms forwards;
-}
-
- 
-@keyframes fadeIn {
-  from {
-    opacity: 0;
-    transform: translateY(5px);
+    display: contents;
   }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
 
- 
-@keyframes fadeOut {
-  from {
-    opacity: 1;
-    transform: translateY(0);
+  .tooltip {
+    --arrow-size: 6px;
+    --arrow-color: var(--nile-tooltip-color-background);
   }
-  to {
-    opacity: 0;
-    transform: translateY(5px);
+
+  .tooltip::part(popup) {
+    pointer-events: none;
+    z-index: 1000;
   }
-}
 
+  .tooltip[placement^='top']::part(popup) {
+    transform-origin: bottom;
+  }
 
+  .tooltip[placement^='bottom']::part(popup) {
+    transform-origin: top;
+  }
 
+  .tooltip[placement^='left']::part(popup) {
+    transform-origin: right;
+  }
 
+  .tooltip[placement^='right']::part(popup) {
+    transform-origin: left;
+  }
 
+  .tooltip__body {
+    display: block;
+    width: max-content;
+    max-width: var(--max-width);
+    border-radius: 4px;
+    background-color: var(--nile-tooltip-color-background);
+    font-size: var(--nile-tooltip-font-size-sm);
+    font-weight: var(--nile-tooltip-font-weight-sm);
+    line-height: var(--nile-tooltip-line-height-sm);
+    padding: var(--nile-tooltip-padding-y) var(--nile-tooltip-padding-x);
+    color: var(--nile-colors-white-base);
+    pointer-events: none;
+    word-break: break-word;
+  }
 
- 
+  .tooltip__body--large {
+    font-size: var(--nile-tooltip-font-size-lg);
+    line-height: var(--nile-tooltip-line-height-lg);
+    font-weight: var(--nile-tooltip-font-weight-lg);
+  }
 `;
 
-export default [styles];
+export default [styles];