@exmg/exm-collapsed 0.0.2-alpha.0

package/README.md

@@ -0,0 +1,65 @@
+# `<exm-collapsed>` [![Published on npm](https://img.shields.io/npm/v/@exmg/exm-collapsed.svg)](https://www.npmjs.com/package/@exmg/exm-collapsed)
+
+Collapsed element contains a slot that can be expanded or collapsed to reveal additional content or information.
+
+[Demo](https://exmg.github.io/exmachina-web-components/demo/?el=exm-collapsed)
+
+## Installation
+
+```sh
+npm install @exmg/exm-collapsed
+```
+
+## Example Usage
+
+### Standard
+
+```js
+@property({type:  Boolean})
+opened = false;
+```
+
+```html
+<exm-button @click="${()" =""> (this.opened = !this.opened)}>Open</exm-button>
+
+<exm-collapsed ?opened="${this.opened}">
+  Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
+  aliqua.
+</exm-collapsed>
+```
+
+## API
+
+### Slots
+
+| Name      | Description                                               |
+| --------- | --------------------------------------------------------- |
+| _default_ | Default content to display within the collapsible element |
+
+### Properties/Attributes
+
+| Name     | Type      | Default | Description                       |
+| -------- | --------- | ------- | --------------------------------- |
+| `opened` | `boolean` | `false` | The opened state of the component |
+
+### Methods
+
+| Name     | Description                                       |
+| -------- | ------------------------------------------------- |
+| `toggle` | Toggles the opened state of the component         |
+| `show`   | Sets the opened state of the component to _true_  |
+| `hide`   | Sets the opened state of the component to _false_ |
+
+### Events
+
+_None_
+
+### CSS Custom Properties
+
+_None_
+
+## Additional references
+
+- [Additional Documentation](https://exmg.github.io/exmachina-web-components/ExmCollapsed.html)
+
+- [Demo](https://exmg.github.io/exmachina-web-components/demo/?el=exm-collapsed)

package/dist/exm-collapsed-base.d.ts

@@ -0,0 +1,53 @@
+import { ExmgElement } from '@exmg/lit-base/index.js';
+export declare class ExmCollapsedBase extends ExmgElement {
+    /**
+     * Whether or not the element is opened or not
+     * @type {Boolean}
+     */
+    opened: boolean;
+    /**
+     * Whether the element is transitioning or not
+     * @type {Boolean}
+     */
+    transitioning: boolean;
+    _desiredSize: string;
+    _initialized: boolean;
+    constructor();
+    /**
+     * Toggle the current(opened/closed) state.
+     * @public
+     */
+    toggle(): void;
+    /**
+     * Set the opened state
+     * @public
+     */
+    show(): void;
+    /**
+     * Set the closed state
+     * @public
+     */
+    hide(): void;
+    /**
+     * @private
+     */
+    _calcSize(): string;
+    /**
+     * @private
+     */
+    _updateTransition(enabled: boolean): void;
+    updateSize(size: string, animated: boolean): void;
+    /**
+     * @private
+     */
+    _openedChanged(): void;
+    /**
+     * @private
+     */
+    _onTransitionEnd(event: TransitionEvent): void;
+    /**
+     * @private
+     */
+    _transitionEnd(): void;
+    protected render(): import("lit-html").TemplateResult<1>;
+}

package/dist/exm-collapsed-base.js

@@ -0,0 +1,164 @@
+import { __decorate } from "tslib";
+import { html } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { observer, ExmgElement } from '@exmg/lit-base/index.js';
+/**
+ * Helper function to toggle element
+ * @param className
+ * @param el
+ * @param val
+ */
+const toggleClass = (className, el, val) => {
+    if (val !== undefined) {
+        if (val) {
+            if (!el.classList.contains(className)) {
+                el.classList.add(className);
+            }
+        }
+        else {
+            el.classList.remove(className);
+        }
+    }
+    else {
+        el.classList.toggle(className);
+    }
+};
+export class ExmCollapsedBase extends ExmgElement {
+    constructor() {
+        super();
+        /**
+         * Whether or not the element is opened or not
+         * @type {Boolean}
+         */
+        this.opened = false;
+        /**
+         * Whether the element is transitioning or not
+         * @type {Boolean}
+         */
+        this.transitioning = false;
+        this._desiredSize = '';
+        this._initialized = false;
+        this.addEventListener('transitionend', this._onTransitionEnd.bind(this));
+        this.setAttribute('role', 'group');
+        this.setAttribute('aria-hidden', 'true');
+    }
+    /**
+     * Toggle the current(opened/closed) state.
+     * @public
+     */
+    toggle() {
+        this.opened = !this.opened;
+    }
+    /**
+     * Set the opened state
+     * @public
+     */
+    show() {
+        this.opened = true;
+    }
+    /**
+     * Set the closed state
+     * @public
+     */
+    hide() {
+        this.opened = false;
+    }
+    /**
+     * @private
+     */
+    _calcSize() {
+        return this.getBoundingClientRect()['height'] + 'px';
+    }
+    /**
+     * @private
+     */
+    _updateTransition(enabled) {
+        this.style.transitionDuration = enabled ? '' : '0s';
+    }
+    updateSize(size, animated) {
+        // Consider 'auto' as '', to take full size.
+        size = size === 'auto' ? '' : size;
+        let willAnimate = animated && this._desiredSize !== size;
+        this._desiredSize = size;
+        this._updateTransition(false);
+        // If we can animate, must do some prep work.
+        if (willAnimate) {
+            // Animation will start at the current size.
+            const startSize = this._calcSize();
+            // For `auto` we must calculate what is the final size for the animation.
+            // After the transition is done, _transitionEnd will set the size back to
+            // `auto`.
+            if (size === '') {
+                this.style['maxHeight'] = '';
+                size = this._calcSize();
+            }
+            // Go to startSize without animation.
+            this.style['maxHeight'] = startSize;
+            // Force layout to ensure transition will go. Set scrollTop to itself
+            // so that compilers won't remove it.
+            // eslint-disable-next-line no-self-assign
+            this.scrollTop = this.scrollTop;
+            // Enable animation.
+            this._updateTransition(true);
+            // If final size is the same as startSize it will not animate.
+            willAnimate = size !== startSize;
+        }
+        // Set the final size.
+        this.style['maxHeight'] = size;
+        // If it won't animate, call transitionEnd to set correct classes.
+        if (!willAnimate) {
+            this._transitionEnd();
+        }
+    }
+    /**
+     * @private
+     */
+    _openedChanged() {
+        this.setAttribute('aria-hidden', String(!this.opened));
+        if (this._initialized) {
+            this.transitioning = true;
+        }
+        toggleClass('collapse-closed', this, false);
+        toggleClass('collapse-opened', this, false);
+        this.updateSize(this.opened ? 'auto' : '0px', this._initialized);
+        // Focus the current collapse.
+        if (this.opened) {
+            this.focus();
+        }
+        this._initialized = true;
+    }
+    /**
+     * @private
+     */
+    _onTransitionEnd(event) {
+        if (event.target === this) {
+            this._transitionEnd();
+        }
+    }
+    /**
+     * @private
+     */
+    _transitionEnd() {
+        this.style['maxHeight'] = String(this._desiredSize);
+        toggleClass('collapse-closed', this, !this.opened);
+        toggleClass('collapse-opened', this, this.opened);
+        this._updateTransition(false);
+        this.transitioning = false;
+    }
+    render() {
+        return html ` <slot></slot> `;
+    }
+}
+__decorate([
+    property({ type: Boolean, reflect: true }),
+    observer(function () {
+        this._openedChanged();
+    })
+], ExmCollapsedBase.prototype, "opened", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], ExmCollapsedBase.prototype, "transitioning", void 0);
+__decorate([
+    state()
+], ExmCollapsedBase.prototype, "_desiredSize", void 0);
+//# sourceMappingURL=exm-collapsed-base.js.map

package/dist/exm-collapsed.d.ts

@@ -0,0 +1,15 @@
+import { ExmCollapsedBase } from './exm-collapsed-base.js';
+/**
+ * 'exm-collapsed' element contains a slot that can be expanded or collapsed to reveal additional content or information.
+ *
+ * @customElement exm-collapsed
+ * @extends ExmCollapsedBase
+ */
+export declare class ExmCollapsed extends ExmCollapsedBase {
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'exm-collapsed': ExmCollapsed;
+    }
+}

package/dist/exm-collapsed.js

@@ -0,0 +1,18 @@
+import { __decorate } from "tslib";
+import { customElement } from 'lit/decorators.js';
+import { ExmCollapsedBase } from './exm-collapsed-base.js';
+import { style } from './styles/exm-collapsed-styles-css.js';
+/**
+ * 'exm-collapsed' element contains a slot that can be expanded or collapsed to reveal additional content or information.
+ *
+ * @customElement exm-collapsed
+ * @extends ExmCollapsedBase
+ */
+let ExmCollapsed = class ExmCollapsed extends ExmCollapsedBase {
+};
+ExmCollapsed.styles = [style];
+ExmCollapsed = __decorate([
+    customElement('exm-collapsed')
+], ExmCollapsed);
+export { ExmCollapsed };
+//# sourceMappingURL=exm-collapsed.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ExmCollapsed } from './exm-collapsed.js';
+export { ExmCollapsedBase } from './exm-collapsed-base.js';
+export { style as collapsedStyles } from './styles/exm-collapsed-styles-css.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { ExmCollapsed } from './exm-collapsed.js';
+export { ExmCollapsedBase } from './exm-collapsed-base.js';
+export { style as collapsedStyles } from './styles/exm-collapsed-styles-css.js';
+//# sourceMappingURL=index.js.map

package/dist/styles/exm-collapsed-styles-css.d.ts

@@ -0,0 +1 @@
+export declare const style: import("lit").CSSResult;

package/dist/styles/exm-collapsed-styles-css.js

@@ -0,0 +1,18 @@
+import { css } from 'lit';
+export const style = css `
+  :host {
+    display: block;
+    transition-duration: 300ms;
+    -webkit-transition-duration: 300ms;
+    overflow: visible;
+  }
+
+  :host(.collapse-closed) {
+    display: none;
+  }
+
+  :host(:not(.collapse-closed)) {
+    overflow: hidden;
+  }
+`;
+//# sourceMappingURL=exm-collapsed-styles-css.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@exmg/exm-collapsed",
+  "version": "0.0.2-alpha.0+df24e0c",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./exm-collapsed.js": "./dist/exm-collapsed.js"
+  },
+  "peerDependencies": {
+    "@exmg/lit-base": "^3.0.3",
+    "lit": "^3.2.1",
+    "tslib": "^2.6.2"
+  },
+  "keywords": [
+    "web-components",
+    "lit",
+    "collapsed"
+  ],
+  "files": [
+    "**/*.scss",
+    "**/*.js",
+    "**/*.d.ts"
+  ],
+  "homepage": "https://bitbucket.org/exmachina/exm-web-components",
+  "repository": {
+    "type": "git",
+    "url": "git@bitbucket.org:exmachina/exm-web-components.git",
+    "directory": "packages/exm-collapsed"
+  },
+  "license": "MIT",
+  "scripts": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "df24e0c74a76a7e1c258f69386036e24e7860256"
+}