@kubex/zinc 0.0.2 → 1.0.0

package/src/utilities/animation-registry.ts

@@ -0,0 +1,74 @@
+export interface ElementAnimation {
+  keyframes: Keyframe[];
+  rtlKeyframes?: Keyframe[];
+  options?: KeyframeAnimationOptions;
+}
+
+export interface ElementAnimationMap {
+  [animationName: string]: ElementAnimation;
+}
+
+export interface GetAnimationOptions {
+  /**
+   * The component's directionality. When set to "rtl", `rtlKeyframes` will be preferred over `keyframes` where
+   * available using getAnimation().
+   */
+  dir: string;
+}
+
+const defaultAnimationRegistry = new Map<string, ElementAnimation>();
+const customAnimationRegistry = new WeakMap<Element, ElementAnimationMap>();
+
+function ensureAnimation(animation: ElementAnimation | null) {
+  return animation ?? { keyframes: [], options: { duration: 0 } };
+}
+
+//
+// Given an ElementAnimation, this function returns a new ElementAnimation where the keyframes property reflects either
+// keyframes or rtlKeyframes depending on the specified directionality.
+//
+function getLogicalAnimation(animation: ElementAnimation, dir: string) {
+  if (dir.toLowerCase() === 'rtl') {
+    return {
+      keyframes: animation.rtlKeyframes || animation.keyframes,
+      options: animation.options
+    };
+  }
+
+  return animation;
+}
+
+/**
+ * Sets a default animation. Components should use the `name.animation` for primary animations and `name.part.animation`
+ * for secondary animations, e.g. `dialog.show` and `dialog.overlay.show`. For modifiers, use `drawer.showTop`.
+ */
+export function setDefaultAnimation(animationName: string, animation: ElementAnimation | null) {
+  defaultAnimationRegistry.set(animationName, ensureAnimation(animation));
+}
+
+/** Sets a custom animation for the specified element. */
+export function setAnimation(el: Element, animationName: string, animation: ElementAnimation | null) {
+  customAnimationRegistry.set(el, { ...customAnimationRegistry.get(el), [animationName]: ensureAnimation(animation) });
+}
+
+/** Gets an element's animation. Falls back to the default if no animation is found. */
+export function getAnimation(el: Element, animationName: string, options: GetAnimationOptions) {
+  const customAnimation = customAnimationRegistry.get(el);
+
+  // Check for a custom animation
+  if (customAnimation?.[animationName]) {
+    return getLogicalAnimation(customAnimation[animationName], options.dir);
+  }
+
+  // Check for a default animation
+  const defaultAnimation = defaultAnimationRegistry.get(animationName);
+  if (defaultAnimation) {
+    return getLogicalAnimation(defaultAnimation, options.dir);
+  }
+
+  // Fall back to an empty animation
+  return {
+    keyframes: [],
+    options: { duration: 0 }
+  };
+}

package/src/utilities/base-path.ts

@@ -0,0 +1,46 @@
+let basePath = "";
+
+/** Sets the library's base path to the specified directory */
+export function setBasePath(path: string) {
+  basePath = path;
+}
+
+/**
+ * Gets the library's base path.
+ *
+ * The base path is used to load assets such as icons and images, so it needs to be set for components to work properly.
+ * By default, this script will look for a script ending in zinc.js or zinc-autoloader.js and set the base path
+ * to the directory that contains that file. To override this behavior, you can add the data-zinc attribute to any
+ * script on the page (it probably makes the most sense to attach it to the Zinc script, but it could also be on a
+ * bundle). The value can be a local folder, or it can point to a CORS-enabled endpoint such as a CDN.
+ *
+ *   <script src="bundle.js" data-zinc="/custom/base/path"></script>
+ *
+ * Alternatively, you can set the base path manually using the exported setBasePath() function.
+ *
+ * @param subpath - An optional path to append to the base path.
+ */
+export function getBasePath(subpath = "") {
+  if (!basePath) {
+    const scripts = [...document.getElementsByTagName("script")] as HTMLScriptElement[];
+    const configScript = scripts.find(script => script.hasAttribute("data-zinc"));
+
+    if (configScript) {
+      // USe the data-zinc attribute
+      setBasePath(configScript.getAttribute("data-zinc")!);
+    } else {
+      const fallbackScript = scripts.find(s => {
+        return /zn(\.min)?.js($|\?)/.test(s.src) || /zinc-autoloader(\.min)?.js($|\?)/.test(s.src);
+      })
+      let path = "";
+
+      if (fallbackScript) {
+        path = fallbackScript.getAttribute("src")!;
+      }
+
+      setBasePath(path.split('/').slice(0, -1).join('/'));
+    }
+  }
+
+  return basePath.replace(/\/$/, '') + (subpath ? `/${subpath.replace(/^\//, '')}` : ``);
+}

package/src/utilities/lit-to-html.ts

@@ -0,0 +1,7 @@
+import {render, type TemplateResult} from "lit";
+
+export function litToHTML<T extends HTMLElement>(templateResult: TemplateResult): T | null {
+  const fragment = document.createDocumentFragment();
+  render(templateResult, fragment)
+  return fragment.firstElementChild as T;
+}

package/src/utilities/localize.ts

@@ -0,0 +1,37 @@
+import {LocalizeController as DefaultLocalizationController, registerTranslation} from '@shoelace-style/localize';
+import type {Translation as DefaultTranslation} from '@shoelace-style/localize';
+
+// Register English as the default/fallback language
+import en from '../translations/en.js';
+
+// Extend the controller and apply our own translation interface for better typings
+export class LocalizeController extends DefaultLocalizationController<Translation> {
+  // Technically '../translations/en.js' is supposed to work via side-effects. However, by some mystery sometimes the
+  // translations don't get bundled as expected resulting in `no translation found` errors.
+  // This is basically some extra assurance that our translations get registered prior to our localizer connecting in a component
+  // and we don't rely on implicit import ordering.
+  static {
+    registerTranslation(en);
+  }
+}
+
+// Export functions from the localize lib so we have one central place to import them from
+export {registerTranslation} from '@shoelace-style/localize';
+
+export interface Translation extends DefaultTranslation {
+  $code: string; // e.g. en, fr
+  $name: string; // e.g. English, French
+  $dir: 'ltr' | 'rtl';
+
+  onChange: string;
+  hidePassword: string;
+  showPassword: string;
+  clearEntry: string;
+  numOptionsSelected: (num: number) => string;
+  fileButtonText: string;
+  fileButtonTextMultiple: string;
+  folderButtonText: string;
+  folderDragDrop: string;
+  fileDragDrop: string;
+  numFilesSelected: (num: number) => string;
+}

package/src/utilities/md5.ts

@@ -0,0 +1,216 @@
+/* eslint-disable */
+export function md5(string: string): string {
+
+  function RotateLeft(lValue: number, iShiftBits: number) {
+    return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
+  }
+
+  function AddUnsigned(lX: number, lY: number) {
+    let lX4, lY4, lX8, lY8, lResult;
+    lX8 = (lX & 0x80000000);
+    lY8 = (lY & 0x80000000);
+    lX4 = (lX & 0x40000000);
+    lY4 = (lY & 0x40000000);
+    lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
+    if (lX4 && lY4) {
+      return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
+    }
+    if (lX4 || lY4) {
+      if (lResult && 0x40000000) {
+        return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
+      } else {
+        return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
+      }
+    } else {
+      return (lResult ^ lX8 ^ lY8);
+    }
+  }
+
+  function F(x: number, y: number, z: number) {
+    return (x & y) | ((~x) & z);
+  }
+
+  function G(x: number, y: number, z: number) {
+    return (x & z) | (y & (~z));
+  }
+
+  function H(x: number, y: number, z: number) {
+    return (x ^ y ^ z);
+  }
+
+  function I(x: number, y: number, z: number) {
+    return (y ^ (x | (~z)));
+  }
+
+  function FF(a: number, b: number, c: number, d: number, x: number, s: number, ac: number) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function GG(a: number, b: number, c: number, d: number, x: number, s: number, ac: number) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function HH(a: number, b: number, c: number, d: number, x: number, s: number, ac: number) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function II(a: number, b: number, c: number, d: number, x: number, s: number, ac: number) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function ConvertToWordArray(string: string) {
+    var lWordCount;
+    var lMessageLength = string.length;
+    var lNumberOfWords_temp1 = lMessageLength + 8;
+    var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
+    var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
+    var lWordArray = Array(lNumberOfWords - 1);
+    var lBytePosition = 0;
+    var lByteCount = 0;
+    while (lByteCount < lMessageLength) {
+      lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+      lBytePosition = (lByteCount % 4) * 8;
+      lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
+      lByteCount++;
+    }
+    lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+    lBytePosition = (lByteCount % 4) * 8;
+    lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
+    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
+    lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
+    return lWordArray;
+  }
+
+  function WordToHex(lValue: number) {
+    var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
+    for (lCount = 0; lCount <= 3; lCount++) {
+      lByte = (lValue >>> (lCount * 8)) & 255;
+      WordToHexValue_temp = "0" + lByte.toString(16);
+      WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
+    }
+    return WordToHexValue;
+  }
+
+  function Utf8Encode(string: string) {
+    string = string.replace(/\r\n/g, "\n");
+    let utftext = "";
+
+    for (let n = 0; n < string.length; n++) {
+
+      const c = string.charCodeAt(n);
+
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      } else if ((c > 127) && (c < 2048)) {
+        utftext += String.fromCharCode((c >> 6) | 192);
+        utftext += String.fromCharCode((c & 63) | 128);
+      } else {
+        utftext += String.fromCharCode((c >> 12) | 224);
+        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+
+    }
+
+    return utftext;
+  }
+
+  let x: any[];
+  let k, AA, BB, CC, DD, a, b, c, d;
+  const S11 = 7, S12 = 12, S13 = 17, S14 = 22;
+  const S21 = 5, S22 = 9, S23 = 14, S24 = 20;
+  const S31 = 4, S32 = 11, S33 = 16, S34 = 23;
+  const S41 = 6, S42 = 10, S43 = 15, S44 = 21;
+
+  string = Utf8Encode(string);
+
+  x = ConvertToWordArray(string);
+
+  a = 0x67452301;
+  b = 0xEFCDAB89;
+  c = 0x98BADCFE;
+  d = 0x10325476;
+
+  for (k = 0; k < x.length; k += 16) {
+    AA = a;
+    BB = b;
+    CC = c;
+    DD = d;
+    a = FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
+    d = FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
+    c = FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
+    b = FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
+    a = FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
+    d = FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
+    c = FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
+    b = FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
+    a = FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
+    d = FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
+    c = FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
+    b = FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
+    a = FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
+    d = FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
+    c = FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
+    b = FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
+    a = GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
+    d = GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
+    c = GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
+    b = GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
+    a = GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
+    d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
+    c = GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
+    b = GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
+    a = GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
+    d = GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
+    c = GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
+    b = GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
+    a = GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
+    d = GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
+    c = GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
+    b = GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
+    a = HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
+    d = HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
+    c = HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
+    b = HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
+    a = HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
+    d = HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
+    c = HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
+    b = HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
+    a = HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
+    d = HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
+    c = HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
+    b = HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
+    a = HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
+    d = HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
+    c = HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
+    b = HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
+    a = II(a, b, c, d, x[k + 0], S41, 0xF4292244);
+    d = II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
+    c = II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
+    b = II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
+    a = II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
+    d = II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
+    c = II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
+    b = II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
+    a = II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
+    d = II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
+    c = II(c, d, a, b, x[k + 6], S43, 0xA3014314);
+    b = II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
+    a = II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
+    d = II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
+    c = II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
+    b = II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
+    a = AddUnsigned(a, AA);
+    b = AddUnsigned(b, BB);
+    c = AddUnsigned(c, CC);
+    d = AddUnsigned(d, DD);
+  }
+
+  var temp = WordToHex(a) + WordToHex(b) + WordToHex(c) + WordToHex(d);
+
+  return temp.toLowerCase();
+}

package/src/utilities/on.ts

@@ -0,0 +1,29 @@
+type OnEvent = Event & { selectedTarget: EventTarget; path: EventTarget[] };
+
+interface OnEventListener {
+  (evt: OnEvent): void;
+}
+
+export function on(delegate: EventTarget, eventName: string, targetSelector: string, callback: OnEventListener) {
+  function _fn(e: OnEvent) {
+    const path = e.path || (e.composedPath?.());
+    let t: Element | null = (path?.[0] || e.target) as Element;
+    do {
+      if (!targetSelector || (t.matches && t.matches(targetSelector))) {
+        e.selectedTarget = t;
+        return callback(e);
+      }
+
+      // stop traversing up the dom once we reach the delegate
+      if (delegate === t) {
+        break;
+      }
+    }
+    while ((t = t.parentElement));
+
+    return false;
+  }
+
+  delegate.addEventListener(eventName, _fn);
+  return () => delegate.removeEventListener(eventName, _fn);
+}

package/src/utilities/query.ts

@@ -0,0 +1,36 @@
+export function deepQuerySelectorAll(selector: string, element: Element, stopSelector: string): Element[] {
+  const arr: Element[] = [];
+
+  const traverser = (node: Element, sub: boolean) => {
+    // 1. decline all nodes that are not elements
+    if (node.nodeType !== Node.ELEMENT_NODE || (sub && stopSelector && node.matches(stopSelector))) {
+      return;
+    }
+
+    // 2. add the node to the array, if it matches the selector
+    if (node.matches(selector)) {
+      arr.push(node);
+    }
+
+    // 3. loop through the children
+    const children = node.children;
+    if (children.length) {
+      for (const child of children) {
+        traverser(child, true);
+      }
+    }
+
+    // 4. check for shadow DOM, and loop through it's children
+    const shadowRoot = node.shadowRoot;
+    if (shadowRoot) {
+      const shadowChildren = shadowRoot.children;
+      for (const shadowChild of shadowChildren) {
+        traverser(shadowChild, true);
+      }
+    }
+  };
+
+  traverser(element, false);
+
+  return arr;
+}

package/src/wc.scss

@@ -0,0 +1,33 @@
+//@use "../scss/shared/reset";
+//@use "../scss/shared/base";
+
+//@use "../scss/shared/layout";
+//@use "../scss/global-spacing";
+
+@forward "../scss/variables";
+@forward "../scss/mixins";
+
+
+:host {
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  *, *::before, *::after {
+    box-sizing: border-box;
+    border-width: 0;
+    border-style: solid;
+    border-color: rgb(var(--zn-border-color));
+  }
+}
+
+[hidden] {
+  display: none !important;
+}
+
+.width-container {
+  height: 100%;
+  width: 100%;
+  max-width: var(--zn-container);
+  margin: 0 auto;
+}

package/src/zinc-autoloader.ts

@@ -0,0 +1,58 @@
+import {getBasePath} from "./utilities/base-path";
+
+const observer = new MutationObserver((mutations) => {
+  for (const {addedNodes} of mutations) {
+    for (const node of addedNodes) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        discover(node as Element);
+      }
+    }
+  }
+});
+
+/**
+ * Checks a node for undefined elements and attempts to register them
+ */
+export async function discover(root: Element | ShadowRoot) {
+  const rootTagName = root instanceof Element ? root.tagName.toLowerCase() : '';
+  const rootIsZincElement = rootTagName?.startsWith('zn-');
+  const tags = [...root.querySelectorAll(':not(:defined)')]
+    .map(el => el.tagName.toLowerCase())
+    .filter(tag => tag.startsWith('zn-'));
+
+  // If the root element is an undefined Zinc component, add it to the list
+  if (rootIsZincElement && !customElements.get(rootTagName)) {
+    tags.push(rootTagName);
+  }
+
+  // Make the list unique
+  const tagsToRegister = [...new Set(tags)];
+
+  await Promise.allSettled(tagsToRegister.map(tagName => register(tagName)));
+}
+
+/**
+ * Registers an element by tag name.
+ */
+function register(tagName: string): Promise<void> {
+  // If the element is already defined, there's nothing more to do
+  if (customElements.get(tagName)) {
+    return Promise.resolve();
+  }
+
+  const tagWithoutPrefix = tagName.replace(/^zn-/i, '');
+  const path = getBasePath(`components/${tagWithoutPrefix}/${tagWithoutPrefix}.js`);
+
+  // Register it
+  return new Promise((resolve, reject) => {
+    // @ts-expect-error  Dynamic imports are only supported when the --module flag is set to es2020, es2022, esnext,
+    // commonjs, amd, system, umd, node16, or nodenext
+    import(path).then(() => resolve()).catch(() => reject(new Error(`Unable to autoload <${tagName}> from ${path}`)));
+  });
+}
+
+// Initial discovery
+discover(document.body);
+
+// Listen for new undefined elements
+observer.observe(document.documentElement, {subtree: true, childList: true});

package/src/zinc.ts

@@ -0,0 +1,83 @@
+// Components
+export {default as Button} from './components/button';
+export {default as Icon} from './components/icon';
+export {default as AbsoluteContainer} from './components/absolute-container';
+export {default as Tooltip} from './components/tooltip';
+export {default as Popup} from './components/popup';
+export {default as Collapsible} from './components/collapsible';
+export {default as Alert} from './components/alert';
+export {default as ButtonGroup} from './components/button-group';
+export {default as Chip} from './components/chip';
+export {default as Well} from './components/well';
+export {default as CopyButton} from './components/copy-button';
+export {default as DataTable} from './components/data-table';
+export {default as Cols} from './components/cols';
+export {default as Confirm} from './components/confirm';
+export {default as Dialog} from './components/dialog';
+export {default as Dropdown} from './components/dropdown';
+export {default as Menu} from './components/menu';
+export {default as MenuItem} from './components/menu-item';
+export {default as DefinedLabel} from './components/defined-label';
+export {default as EmptyState} from './components/empty-state';
+export {default as Note} from './components/note';
+export {default as Tile} from './components/tile';
+export {default as TileProperty} from './components/tile-property';
+export {default as Chart} from './components/chart';
+export {default as SimpleChart} from './components/simple-chart';
+export {default as Header} from './components/header';
+export {default as Navbar} from './components/navbar';
+export {default as InlineEdit} from './components/inline-edit';
+export {default as Pagination} from './components/pagination';
+export {default as VerticalStepper} from './components/vertical-stepper';
+export {default as Timer} from './components/timer';
+export {default as Tabs} from './components/tabs';
+export {default as Panel} from './components/panel';
+export {default as Table} from './components/table';
+export {default as Pane} from './components/pane';
+export {default as SplitPane} from './components/split-pane';
+export {default as Sidebar} from './components/sidebar';
+export {default as Sp} from './components/sp';
+export {default as Stepper} from './components/stepper';
+export {default as Stat} from './components/stat';
+export {default as ScrollContainer} from './components/scroll-container';
+export {default as QueryBuilder} from './components/query-builder';
+export {default as ProgressTile} from './components/progress-tile';
+export {default as ProgressBar} from './components/progress-bar';
+export {default as OrderTable} from './components/order-table';
+export {default as BulkActions} from './components/bulk-actions';
+export {default as Editor} from './components/editor';
+export {default as Toggle} from './components/toggle';
+export {default as Input} from './components/input';
+export {default as Select} from './components/select';
+export {default as Option} from './components/option';
+export {default as Textarea} from './components/textarea';
+export {default as Checkbox} from './components/checkbox';
+export {default as Datepicker} from './components/datepicker';
+export {default as FormGroup} from './components/form-group';
+export {default as LinkedSelect} from './components/linked-select';
+export {default as Radio} from './components/radio';
+export {default as Rating} from './components/rating';
+export {default as RadioGroup} from './components/radio-group';
+export {default as File} from './components/file';
+export {default as CheckboxGroup} from './components/checkbox-group';
+export {default as Item} from './components/item';
+export {default as DataSelect} from './components/data-select';
+export {default as ButtonMenu} from './components/button-menu';
+export {default as HoverContainer} from './components/hover-container';
+export {default as Slideout} from './components/slideout';
+export {default as DataTableFilter} from './components/data-table-filter';
+export {default as DataTableSort} from './components/data-table-sort';
+export {default as ActionBar} from './components/action-bar';
+export {default as ExpandingAction} from './components/expanding-action';
+export {default as PageNav} from './components/page-nav';
+export {default as StatusIndicator} from './components/status-indicator';
+export {default as SplitButton} from './components/split-button';
+export {default as Skeleton} from './components/skeleton';
+export {default as Style} from './components/style';
+export {default as ContentBlock} from './components/content-block';
+/* plop:component */
+
+// Utilities
+
+// Events
+export * from './events/events';

package/tsconfig.json

@@ -0,0 +1,41 @@
+/* This is the "dev" TS Config which includes typechecking for test. This is used by ESLint to provide TypeScript errors for test files */
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+    "target": "es2017",
+    "moduleResolution": "node",
+    "lib": [
+      "dom",
+      "dom.Iterable",
+      "ESNext"
+    ],
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "rootDir": ".",
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "strictFunctionTypes": false,
+    "noImplicitThis": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    /* See https://lit.dev/docs/components/properties/#avoiding-issues-with-class-fields */
+    "useDefineForClassFields": false,
+    "removeComments": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "useUnknownInCatchVariables": true,
+    "isolatedModules": false,
+    "verbatimModuleSyntax": false,
+    "types": [
+      "mocha",
+      "user-agent-data-types"
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}

package/tsconfig.prod.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig",
+  "compilerOptions": {
+    "rootDir": "./src"
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "src/**/*.test.ts"
+  ]
+}