@txstate-mws/svelte-components 1.1.0 → 1.1.1

package/package.json

@@ -1,17 +1,7 @@
 {
   "name": "@txstate-mws/svelte-components",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Svelte components that are generically useful.",
-  "scripts": {
-    "dev": "svelte-kit dev",
-    "build": "svelte-kit build",
-    "package": "svelte-kit package",
-    "preview": "svelte-kit preview",
-    "check": "svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-check --tsconfig ./tsconfig.json --watch",
-    "lint": "eslint --ignore-path .gitignore .",
-    "test": "playwright test tests"
-  },
   "dependencies": {
     "@txstate-mws/svelte-store": "^1.0.3",
     "tabbable": "^5.2.1",
@@ -31,5 +21,36 @@
     "tslib": "^2.3.1",
     "typescript": "^4.4.3"
   },
-  "type": "module"
-}
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./actions/buttonify": "./actions/buttonify.js",
+    "./actions/glue": "./actions/glue.js",
+    "./actions": "./actions/index.js",
+    "./actions/offset": "./actions/offset.js",
+    "./actions/portal": "./actions/portal.js",
+    "./actions/resize": "./actions/resize.js",
+    "./actions/sticky": "./actions/sticky.js",
+    "./actions/stickyfixed": "./actions/stickyfixed.js",
+    "./components/Card.svelte": "./components/Card.svelte",
+    "./components/CardLayout.svelte": "./components/CardLayout.svelte",
+    "./components/CollapsingTable.svelte": "./components/CollapsingTable.svelte",
+    "./components/ConditionalWrapper.svelte": "./components/ConditionalWrapper.svelte",
+    "./components/FocusLock.svelte": "./components/FocusLock.svelte",
+    "./components/Modal.svelte": "./components/Modal.svelte",
+    "./components/MultiSelect.svelte": "./components/MultiSelect.svelte",
+    "./components/PopupMenu.svelte": "./components/PopupMenu.svelte",
+    "./components/ScreenReaderOnly.svelte": "./components/ScreenReaderOnly.svelte",
+    "./components": "./components/index.js",
+    ".": "./index.js",
+    "./types/CardLayout": "./types/CardLayout.js",
+    "./types/CollapsingTable": "./types/CollapsingTable.js",
+    "./types/PopupMenu": "./types/PopupMenu.js",
+    "./types": "./types/index.js",
+    "./util/bodyoffset": "./util/bodyoffset.js",
+    "./util": "./util/index.js",
+    "./util/repositioned": "./util/repositioned.js",
+    "./util/util": "./util/util.js"
+  },
+  "svelte": "./index.js"
+}

package/types/CardLayout.d.ts

@@ -0,0 +1,14 @@
+import type { SettableSubject } from '@txstate-mws/svelte-store';
+export declare const CARDLAYOUT: {};
+export interface Block {
+    element: HTMLElement;
+    order?: SettableSubject<number>;
+    linebreak?: SettableSubject<boolean>;
+    width?: SettableSubject<string>;
+    height?: number;
+}
+export interface CardLayoutContext {
+    registerBlock: (block: Block) => Block;
+    recalculate: () => void;
+    gutter: SettableSubject<number>;
+}

package/types/CardLayout.js

@@ -0,0 +1 @@
+export const CARDLAYOUT = {};

package/types/CollapsingTable.d.ts

@@ -0,0 +1,8 @@
+export interface CollapsingTableColumn {
+    key: string;
+    title?: string;
+    width?: number;
+    neverhide?: boolean;
+    bodyCellClass?: string;
+    headerCellClass?: string;
+}

package/types/CollapsingTable.js

@@ -0,0 +1 @@
+export {};

package/types/PopupMenu.d.ts

@@ -0,0 +1,5 @@
+export interface PopupMenuItem {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+}

package/types/PopupMenu.js

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CardLayout.js';
+export * from './CollapsingTable.js';
+export * from './PopupMenu.js';

package/types/index.js

@@ -0,0 +1,3 @@
+export * from './CardLayout.js';
+export * from './CollapsingTable.js';
+export * from './PopupMenu.js';

package/util/bodyoffset.d.ts

@@ -0,0 +1,14 @@
+export declare type ElementOffsets = Partial<ReturnType<typeof bodyOffset>>;
+export declare function bodyOffset(ele: HTMLElement): {
+    right: number;
+    bottom: number;
+    top: number;
+    left: number;
+};
+export declare function targetOffset(ele: HTMLElement, target: HTMLElement): {
+    right: number;
+    bottom: number;
+    top: number;
+    left: number;
+};
+export declare function sharedOffsetParent(a: HTMLElement, b: HTMLElement): HTMLElement;

package/util/bodyoffset.js

@@ -0,0 +1,72 @@
+export function bodyOffset(ele) {
+    return targetOffset(ele, document.body);
+}
+export function targetOffset(ele, target) {
+    const offset = targetOffsetRecursive(ele, target);
+    return {
+        ...offset,
+        right: target.offsetWidth - offset.left - ele.offsetWidth,
+        bottom: target.offsetHeight - offset.top - ele.offsetHeight
+    };
+}
+export function sharedOffsetParent(a, b) {
+    if (!a || !b)
+        return undefined;
+    if (a.contains(b) && a.firstElementChild.offsetParent === a)
+        return a;
+    if (b.contains(a) && b.firstElementChild.offsetParent === b)
+        return b;
+    let c = a.offsetParent;
+    while (c instanceof HTMLElement && !c.contains(b))
+        c = c.offsetParent;
+    return c;
+}
+function targetOffsetRecursive(ele, target, currentOffset) {
+    const { x, y } = getTranslate(ele);
+    const offset = {
+        top: ele.offsetTop + (currentOffset?.top ?? 0) + y,
+        left: ele.offsetLeft + (currentOffset?.left ?? 0) + x
+    };
+    if (ele.offsetParent instanceof HTMLElement && target !== ele.offsetParent && target.contains(ele.offsetParent))
+        return targetOffsetRecursive(ele.offsetParent, target, offset);
+    return offset;
+}
+function getTranslate(element) {
+    const style = window.getComputedStyle(element);
+    const matrix = style.transform;
+    // No transform property. Simply return 0 values.
+    if (matrix === 'none' || !matrix) {
+        return {
+            x: 0,
+            y: 0,
+            z: 0
+        };
+    }
+    // Can either be 2d or 3d transform
+    const matrixType = matrix.includes('3d') ? '3d' : '2d';
+    const matrixValues = matrix.match(/matrix.*\((.+)\)/)[1].split(', ');
+    // 2d matrices have 6 values
+    // Last 2 values are X and Y.
+    // 2d matrices does not have Z value.
+    if (matrixType === '2d') {
+        return {
+            x: Number(matrixValues[4]),
+            y: Number(matrixValues[5]),
+            z: 0
+        };
+    }
+    // 3d matrices have 16 values
+    // The 13th, 14th, and 15th values are X, Y, and Z
+    if (matrixType === '3d') {
+        return {
+            x: Number(matrixValues[12]),
+            y: Number(matrixValues[13]),
+            z: Number(matrixValues[14])
+        };
+    }
+    return {
+        x: 0,
+        y: 0,
+        z: 0
+    };
+}

package/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bodyoffset.js';
+export * from './repositioned.js';
+export * from './util.js';

package/util/index.js

@@ -0,0 +1,3 @@
+export * from './bodyoffset.js';
+export * from './repositioned.js';
+export * from './util.js';

package/util/repositioned.d.ts

@@ -0,0 +1,12 @@
+import type { ElementOffsets } from './bodyoffset.js';
+export declare function watchForMutations(cb: () => void): {
+    destroy(): void;
+};
+export declare function watchForPositionChange(el: (HTMLElement | undefined)[] | HTMLElement | undefined, cb: ((offset: Required<ElementOffsets>) => void) | ((offsets: Required<ElementOffsets>[]) => void)): {
+    update(newEl: (HTMLElement | undefined)[] | HTMLElement | undefined, newCb: ((offset: Required<ElementOffsets>) => void) | ((offsets: Required<ElementOffsets>[]) => void)): void;
+    destroy: () => void;
+};
+export declare function watchForPositionChangeInContainer(el: HTMLElement | undefined, container: HTMLElement | undefined, cb: (offset: Required<ElementOffsets>) => void): {
+    update(newEl: HTMLElement | undefined, newContainer: HTMLElement | undefined, newCb: (offset: Required<ElementOffsets>) => void): void;
+    destroy: () => void;
+};

package/util/repositioned.js

@@ -0,0 +1,81 @@
+import { equal, isNotNull, randomid, toArray } from 'txstate-utils';
+import { bodyOffset, targetOffset } from './bodyoffset.js';
+const observers = new Map();
+let mutationobserver;
+export function watchForMutations(cb) {
+    function watch() {
+        for (const cb of observers.values())
+            cb();
+    }
+    if (observers.size === 0) {
+        mutationobserver ?? (mutationobserver = new MutationObserver(watch));
+        window.addEventListener('resize', watch, { passive: true });
+        mutationobserver.observe(document.body, {
+            subtree: true,
+            childList: true,
+            attributes: true,
+            characterData: true
+        });
+    }
+    const id = randomid();
+    observers.set(id, cb);
+    cb();
+    return {
+        destroy() {
+            observers.delete(id);
+            if (observers.size === 0) {
+                window.removeEventListener('resize', watch);
+                mutationobserver.disconnect();
+            }
+        }
+    };
+}
+export function watchForPositionChange(el, cb) {
+    let lastoffsets = [];
+    let els = toArray(el).filter(isNotNull);
+    function watch() {
+        const offsets = els.map(bodyOffset);
+        if (offsets.some((offset, i) => !equal(offset, lastoffsets[i]))) {
+            lastoffsets = offsets;
+            Array.isArray(el) ? cb(offsets) : cb(offsets[0]);
+        }
+    }
+    const { destroy } = watchForMutations(watch);
+    return {
+        update(newEl, newCb) {
+            const changed = newEl !== el || newCb !== cb;
+            if (changed) {
+                el = newEl;
+                els = toArray(el).filter(isNotNull);
+                cb = newCb;
+                watch();
+            }
+        },
+        destroy
+    };
+}
+export function watchForPositionChangeInContainer(el, container, cb) {
+    let lastoffset;
+    function watch() {
+        if (!el || !container)
+            return;
+        const offset = targetOffset(el, container);
+        if (!equal(offset, lastoffset)) {
+            lastoffset = offset;
+            cb(offset);
+        }
+    }
+    const { destroy } = watchForMutations(watch);
+    return {
+        update(newEl, newContainer, newCb) {
+            const changed = newEl !== el || newContainer !== container || newCb !== cb;
+            if (changed) {
+                el = newEl;
+                container = newContainer;
+                cb = newCb;
+                watch();
+            }
+        },
+        destroy
+    };
+}

package/util/util.d.ts

@@ -0,0 +1,5 @@
+export declare function classes(...classNames: (string | undefined)[]): string;
+export declare function debounced(fn: Function, timeout: number): (...args: any[]) => void;
+export declare function debouncedPromise<T>(fn: (..._: any) => Promise<T> | T, timeout: number, defaultValue: T): (..._: any) => Promise<T>;
+export declare function modifierKey(e: any): any;
+export declare function selectionIsLeft(ele: HTMLInputElement | HTMLTextAreaElement): boolean;

package/util/util.js

@@ -0,0 +1,33 @@
+export function classes(...classNames) {
+    return classNames.filter(Boolean).join(' ');
+}
+export function debounced(fn, timeout) {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fn(...args), timeout);
+    };
+}
+export function debouncedPromise(fn, timeout, defaultValue) {
+    let version = 0;
+    return async (...args) => {
+        const myversion = ++version;
+        return await new Promise(resolve => {
+            setTimeout(() => {
+                if (version === myversion) {
+                    version = 0;
+                    resolve(fn(...args));
+                }
+                else {
+                    resolve(defaultValue);
+                }
+            }, timeout);
+        });
+    };
+}
+export function modifierKey(e) {
+    return e.ctrlKey || e.altKey || e.metaKey || e.key === 'Insert';
+}
+export function selectionIsLeft(ele) {
+    return ele.selectionStart === 0 && ele.selectionEnd === 0;
+}

package/.eslintrc.cjs

@@ -1,37 +0,0 @@
-module.exports = {
-	root: true,
-	parser: '@typescript-eslint/parser',
-	extends: 'standard-with-typescript',
-	plugins: ['svelte3', '@typescript-eslint'],
-	ignorePatterns: ['*.cjs', 'package/**/*', 'svelte.config.js', 'playwright.config.js'],
-	overrides: [{ files: ['*.svelte'], processor: 'svelte3/svelte3' }],
-	settings: {
-		'svelte3/typescript': () => require('typescript')
-	},
-  rules: {
-    'import/first': 'off',
-		'no-multiple-empty-lines': 'off',
-    'no-undef-init': 'off',
-		'no-unused-vars': 'off',
-		'no-use-before-define': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/array-type': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-unused-vars': 'off', // typescript does this better
-    '@typescript-eslint/require-await': 'off',
-    '@typescript-eslint/return-await': ['error', 'always'],
-    '@typescript-eslint/strict-boolean-expressions': 'off',
-    '@typescript-eslint/prefer-readonly': ['off']
-  },
-	parserOptions: {
-		project: './tsconfig.json',
-		sourceType: 'module',
-		extraFileExtensions: ['.svelte'],
-		ecmaVersion: 2020
-	},
-	env: {
-		browser: true,
-		es2017: true,
-		node: true
-	}
-};

package/docs/CollapsingTable.md

@@ -1,79 +0,0 @@
-# Collapsing Table
-
-This component is meant to help make tables responsive by eliminating columns (from the right) as the screen width reduces. When there are hidden columns, the last column header becomes a dropdown button allowing the selection of another column to be displayed instead.
-
-# Usage
-
-The only required prop is an `items` array of objects. Column headers will automatically be detected from object keys if no column configuration is present.
-
-## Column Configuration
-
-A `config` prop allows you to pass an array of column definitions. If passed, only these columns will appear, other keys in your `items` objects will be ignored.
-
-### Variables accepted for each column
-
-* `key: string` corresponds to object key in your `items` objects
-* `title?: string` a display name for this column's header
-* `width?: number` a guess at how wide in pixels this column will be; helps decide when to hide
-                   columns, default 150
-* `neverhide?: boolean`<br>
-  setting to make sure this column is never hidden; good to set on
-  the column that is most identifying for each row, like a name.
-  by default the leftmost column will stick around as identifying
-* `bodyCellClass?: string` CSS class to set on `td` elements in the body area
-* `headerCellClass?: string` CSS class to set on `td` elements in the header row
-
-## Optional Props
- * `tableClass` CSS class for the `table`
- * `bodyRowClass` CSS class for `tr` in the body area
- * `bodyCellClass` CSS class for `td` in the body area, additional to the one set in column config
- * `headerRowClass` CSS class for `tr` on the header row
- * `headerCellClass` CSS class for `th` in the header row, additional to the one set in column config
- * `menuClass` CSS class for the `ul` dropdown menu
- * `menuItemClass` CSS class for `li` in the dropdown menu
- * `menuItemHilitedClass` CSS class for `li` in the dropdown menu when they are currently hilited/active
- * `defaultCellWidth`, guess for any column width in pixels, allows you to hide columns earlier/later, default 150
-
-## Slots
-Lots of slots are provided for extra configuration.
-
-### Default Slot
-The default slot is used for each table cell in the body area. It is optional and falls back to {value}.
-Because of the way slots work, your slot content will be executed in every cell. So if you need to do
-something special for just one cell, you have to use an if/else block to identify the special cell,
-falling back to {value} for everything else:
-```svelte
-<CollapsingTable items={myItems} let:item let:key let:value>
-  {#if key === 'myspecialkey'}
-    <MySpecialComponent>{value}</MySpecialComponent>
-  {:else}
-    {value}
-  {/if}
-</CollapsingTable>
-```
-The slot props are `item`, `key`, and `value`.
-### Header Cell Slot
-A slot named `headercell` allows you to do the same thing for cells in the header row that the
-default slot allows for body cells.
-```svelte
-<CollapsingTable items={myItems} let:column let:key let:title>
-  <div slot="headercell">
-    {#if key === 'myspecialkey'}
-      <MySpecialComponent>{title}</MySpecialComponent>
-    {:else}
-      {title}
-    {/if}
-  </div>
-</CollapsingTable>
-```
-The slot props are `column`, `key`, and `title`. `column` is the configuration object for the
-current column, `title` is `column.title || column.key`. The title/key will be used as fallback
-content if you do not specify a header slot.
-### Dropdown Icon Slot
-A slot is provided for you to provide a custom icon for the column header that is serving as the
-dropdown button.
-```svelte
-<CollapsingTable items={myItems}>
-  <i type='fa caret-down' slot="dropicon" aria-hidden="true"></i>
-</CollapsingTable>
-```

package/docs/ConditionalWrapper.md

@@ -1,35 +0,0 @@
-# Conditional Wrapper
-Sometimes you want to wrap a complex bit of HTML in a certain element based on a condition,
-and not wrap it at all if the condition isn't met. Without help, this situation results in a
-lot of duplicate code because you have to have an if/else block outside the whole thing, and
-the complex HTML goes in both branches:
-```svelte
-{#if shouldwrap}
-  <div class="wrapper">
-    ... a whole bunch of html ...
-  </div>
-{:else}
-  ... a whole bunch of html, again ...
-{/if}
-```
-With this component, you can de-duplicate like this:
-```svelte
-<ConditionalWrapper class="wrapper" condition={shouldwrap}>
-  ... a whole bunch of html ...
-</ConditionalWrapper>
-```
-Any props you provide (except the ConditionalWrapper props like `condition`) will pass through
-to the wrapper element/component, if it gets inserted.
-
-## Props
-* `condition: boolean|undefined` (required) - Whether or not to wrap the element. Accepts `undefined`
-  for convenience when evaluating presence of an optional variable.
-* `component?: SvelteComponent` (optional) - The wrapper will be a svelte component instead of a DOM
-  element. Props all get passed through.
-* `a: boolean` (optional) - The wrapper will be a link element.
-* `span: boolean` (optional) - The wrapper will be a span element.
-* `element?: HTMLElement` (for binding) - If the wrapper is a DOM element, bind this prop to get a
-  reference to wrapper element (if it exists). If the wrapper is a svelte component, this will be
-  passed to it as a prop so that the wrapper component can bind it to a DOM element.
-
-If none of `a`, `span`, or `component` props are specified, the default is to create a `div` wrapper.

package/docs/Modal.md

@@ -1,63 +0,0 @@
-# Modal
-The Modal component is designed to block out the screen and focus the user on the content inside the Modal.
-
-It provides only the backdrop and a scrollable container for your content. If your content should have a background color, be sure to add it yourself.
-
-Any time the Modal is in the DOM, it will take over the screen. You make it go away by removing it from the DOM.
-
-## Example Usage
-```svelte
-<script>
-  let showMyModal = false
-</script>
-<button on:click={() => showMyModal = true}>Show Modal</button>
-{#if showMyModal}
-  <Modal on:escape={() => showMyModal = false}>
-    This is a modal dialog!
-  </Modal>
-{/if}
-<style>
-  :global(.modal-container) { background: white; }
-</style>
-```
-## Custom Events
-* `on:escape` - dispatched when the user does something that would normally dismiss a modal, such as clicking in the darkened backdrop or pressing the Escape key. You should listen for this and dismiss your modal. If you do not listen for this event, users will only be able to escape by some other means provided within your content. Be careful not to trap them!
-
-## Props
-* `opaque: boolean` (default `false`) - Make the backdrop completely opaque so that it cannot be seen through. This is a more jarring experience for users but sometimes you don't want background content to be visible at all.
-* `containerClass: string` (default `''`) - A class to be added to the scrollable container inside the backdrop. This container will always have the `.modal-container` class regardless of this prop.
-* `escapable: boolean` (default `true`) - Let screen readers know that they can escape the modal by pressing the Escape key. If you are not listening for `on:escape` then you should set this `false` to avoid giving screen reader users false information.
-* `hidefocus: boolean` (default `true`) - Focus must be moved to the modal when it opens, in order to maintain accessibility. This component avoids making the focus visible to users by default as it might be visually disconcerting. So on mount, focus is moved to an invisible element above your content. If you prefer focus to be visible to users, set this to `false` and focus will automatically be moved to the first element in your content that has a tabindex and therefore be visible to users. This prop is overridden if you provide an `initialfocus`.
-* `hidefocuslabel: string` (default `focus is above modal dialog, start tabbing`) - The message that will be read out to users using a screen reader when the focus is on the invisible element created by the `hidefocus` prop.
-* `initialfocus: string` (default `undefined`) - A selector to be used to locate and set focus on an element in your content, on mount. Use if you want focus on a specific element when the modal opens. Overrides `hidefocus`.
-* `returnfocusto: HTMLElement` (default element that had focus was when modal opened) - Use to control where focus moves when the modal closes. If not provided, component automatically saves the element that had focus on mount. Usually it's the button that triggered the modal.
-
-# FocusLock
-The FocusLock component is for creating accessible modal dialogs that do not have a darkened backdrop. It shares many props and behaviors with Modal because the Modal component uses a FocusLock itself.
-
-Any time the FocusLock is in the DOM, it will lock screen readers inside it. You release them by removing it from the DOM. Regular users are NOT trapped and may interact with other screen elements. When they do, the `escape` event will be fired, allowing you to remove the dialog.
-
-FocusLocks can be nested. The user will be trapped inside the deepest FocusLock present in the DOM. When it goes away, they'll be trapped inside the previous FocusLock, and so on.
-
-## Custom Events
-* `on:escape` - dispatched when the user does something to dismiss the dialog, such as pressing the Escape key or clicking outside the dialog area. You should listen for this and remove the FocusLock. If you do not listen for this event, users will only be able to escape by some other means provided within your content. Be careful not to trap them!
-
-## Example Usage
-```svelte
-<script>
-  let showMyDialog = false
-</script>
-<button on:click={() => showMyDialog = true}>Show Dialog</button>
-{#if showMyDialog}
-  <FocusLock on:escape={() => showMyDialog = false}>
-    Screen readers cannot escape this!
-    <button on:click={() => showMyDialog = false}>Collapse Dialog</button>
-  </FocusLock>
-{/if}
-```
-## Props
-* `escapable: boolean` (default `true`) - Controls whether the focus lock can be easily escaped by pressing the Escape key or clicking the invisible focus (see `hidefocus`). If you set this `false` you must provide a way to dismiss the lock inside your content or screen readers will be trapped.
-* `hidefocus: boolean` (default `true`) - Focus must be moved to the modal when it opens, in order to maintain accessibility. This component avoids making the focus visible to users by default as it might be visually disconcerting. So on mount, focus is moved to an invisible element above your content. If you prefer focus to be visible to users, set this to `false` and focus will automatically be moved to the first element in your content that has a tabindex and therefore be visible to users. This prop is overridden if you provide an `initialfocus`.
-* `hidefocuslabel: string` (default `focus is above modal dialog, start tabbing`) - The message that will be read out to users using a screen reader when the focus is on the invisible element created by the `hidefocus` prop.
-* `initialfocus: string` (default `undefined`) - A selector to be used to locate and set focus on an element in your content, on mount. Use if you want focus on a specific element when the lock mounts. Overrides `hidefocus`.
-* `returnfocusto: HTMLElement` (default element that had focus was when focuslock mounted) - Use to control where focus moves when the lock ends. If not provided, component automatically saves the element that had focus on mount. Usually it's the button that triggered the dialog.

package/docs/PopupMenu.md

@@ -1,31 +0,0 @@
-# PopupMenu
-
-This component is meant to display a menu of options to the user, activated by clicking
-any element. It can also be controlled from the parent, by binding the `menushown` boolean.
-
-## Props
-* `buttonelement: HTMLElement` (required) - The DOM element that will act as the "button" for this menu. The menu will be placed next to the button and be controlled by the button. Keyboard access will be enabled when the button has focus. This component adds all appropriate attributes (tabindex, roles, and aria) automatically.
-* `items: PopupMenuItem[]` (required) - The list of menu items to be shown. Parent may change this at any time based on user activity.
-* `menushown?: boolean` (default `false`) - Bind this prop to track/change the visible state of the menu from the parent.
-* `value?: string` (default no selection) - Bind this prop to track/change the currently selected value from the parent.
-* `align?: GlueAlignOpts` (default `auto`) - Control where the menu will appear. Default is to use the current viewport to make a decision to maximize potential for menu growth.
-* `cover?: boolean` (default `false`) - When the menu is active, should it cover the button or be rendered above/below it?
-* `showSelected?: boolean` (default `true`) - When an item is currently selected, should it appear in the menu (with a visual indicator), or simply be removed from the list (showSelected: `false`)?
-* `width?: string` (default `undefined`) - When defined, this width will be passed through to the menu's CSS width. Use a valid CSS dimension such as `33em` or `159px`. Generally this will be used when you need to match the menu width to something else, like the button. If the width is static like `100%` a simple CSS rule is likely more efficient.
-* `computedalign: readable<{ valign: 'top'|'bottom', halign: 'left'|'right' }>` (default store is provided) - Bind this prop to receive a store that is updated each time a menu placement decision is made. Example of when this is useful is when you are trying to round corners of your button and need to know whether the menu is above or below your button so you know which corners to round and which to leave square. Note that the values do not update when the menu is hidden, so you may need to rely on `menushown` as well.
-* `usePortal?: HTMLElement|true` (default `false`) - If the menu would be clipped by an `overflow: hidden`, you can set this prop and it will be placed in the specified container, or the `document.body` if you simply say `true`. Placement will still be calculated correctly, unless there are scrolling containers between the button and the menu.
-* `emptyText?: string` (default `¯\_(ツ)_/¯`) - When there are no items (e.g. it's a filtered search and there were no results), we still display one disabled item in the menu to let the user know what is going on. Use this prop to specify the message.
-* `menuContainerClass?: string` (default `''`) - CSS class to pass through so you can do extra styling work
-* `menuClass?: string` (default `''`) - CSS class to pass through so you can do extra styling work
-* `menuItemClass?: string` (default `''`) - CSS class to pass through so you can do extra styling work
-* `menuItemHilitedClass?: string` (default `''`) - CSS class to pass through so you can do extra styling work
-* `menuItemSelectedClass?: string` (default `''`) - CSS class to pass through so you can do extra styling work
-
-## Events
-* `on:change` - Dispatched any time a new value is selected. Does not fire when you change the `value` property from the outside. Event detail will be the full PopupMenuItem object that was selected.
-
-## Types
-* `PopupMenuItem: { value: string, label?: string, disabled?: boolean }` - Each item must have a unique non-empty value. Display label is optional, as is a `disabled` status that will show the item in the list but not allow users to hilite or select it.
-
-## Disabling
-Since there are so many different possibilities for the button you attach to, the PopupMenu does not have a `disabled` prop. If the PopupMenu should be disabled, simply remove it from the DOM with an `{#if}` block. Remember to also set `aria-disabled` on your button and likely provide some visual indicators like `cursor: default` or the `disabled` attribute on elements that support it.

package/docs/ScreenReaderOnly.md

@@ -1,10 +0,0 @@
-# ScreenReaderOnly
-This component is for adding text that can be read to screen readers while remaining
-invisible to regular users. It accepts `arialive` and `ariaatomic` props to pass through to
-the corresponding HTML attributes. It also accepts an `id` prop in case you need to
-point at it with an aria-describedby attribute on some other element.
-
-Using this component is often better than using aria-label because aria-label still has poor support
-and sometimes is not good enough to make WAVE happy with an empty icon-link. It's also a
-good way to add additional text when sighted users have a little text already, e.g. to add
-interactivity instructions.