@workday/canvas-kit-react 8.0.0-alpha.253-next.22 → 8.0.0-alpha.428-next.2

package/dist/commonjs/collection/lib/useListItemRovingFocus.js

@@ -1,142 +1,90 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useListItemRovingFocus = exports.orientationKeyMap = void 0;
-var react_1 = __importDefault(require("react"));
-var common_1 = require("@workday/canvas-kit-react/common");
-var useCursorListModel_1 = require("./useCursorListModel");
-exports.orientationKeyMap = {
-    horizontal: {
-        ArrowLeft: 'goToPrevious',
-        Left: 'goToPrevious',
-        ArrowRight: 'goToNext',
-        Right: 'goToNext',
-        Home: 'goToFirst',
-        End: 'goToLast',
-        PageDown: 'goToNextPage',
-        PageUp: 'goToPreviousPage',
-    },
-    vertical: {
-        ArrowUp: 'goToPrevious',
-        Up: 'goToPrevious',
-        ArrowDown: 'goToNext',
-        Down: 'goToNext',
-        Home: 'goToFirst',
-        End: 'goToLast',
-        PageDown: 'goToNextPage',
-        PageUp: 'goToPreviousPage',
-    },
+exports.useListItemRovingFocus = void 0;
+const react_1 = __importDefault(require("react"));
+const common_1 = require("@workday/canvas-kit-react/common");
+const useCursorListModel_1 = require("./useCursorListModel");
+const keyUtils_1 = require("./keyUtils");
+// retry a function each frame so we don't rely on the timing mechanism of React's render cycle.
+const retryEachFrame = (cb, iterations) => {
+    if (cb() === false && iterations > 1) {
+        requestAnimationFrame(() => retryEachFrame(cb, iterations - 1));
+    }
 };
-var rightToLeftMap = {
-    ArrowLeft: 'ArrowRight',
-    Left: 'Right',
-    ArrowRight: 'ArrowLeft',
-    Right: 'Left',
-    Home: 'Home',
-    End: 'End',
-    PageDown: 'PageDown',
-    PageUp: 'PageUp',
-};
-var gridKeyMap = __assign(__assign({}, exports.orientationKeyMap.horizontal), { Home: 'goToFirstOfRow', End: 'goToLastOfRow', ArrowUp: 'goToPreviousRow', Up: 'goToPreviousRow', ArrowDown: 'goToNextRow', Down: 'goToNextRow' });
-var ctrlKeyMap = {
-    Home: 'goToFirst',
-    End: 'goToLast',
-};
-var keys = function (obj) { return Object.keys(obj); };
-var hasOwnKey = function (obj, key) { return obj.hasOwnProperty(key); };
 /**
- * Handles the roving focus behavior of a Cursor model. It should be added to the element
- * representing a list item.
+ * This elemProps hook is used for cursor navigation by using [Roving
+ * Tabindex](https://w3c.github.io/aria-practices/#kbd_roving_tabindex). Only a single item in the
+ * collection has a tab stop. Pressing an arrow key moves the tab stop to a different item in the
+ * corresponding direction. See the [Roving Tabindex](#roving-tabindex) example. This elemProps hook
+ * should be applied to an `*.Item` component.
  *
- * @see https://www.w3.org/TR/wai-aria-practices/#kbd_roving_tabindex
+ * ```ts
+ * const useMyItem = composeHooks(
+ *   useListItemRovingFocus, // adds the roving tabindex support
+ *   useListItemRegister
+ * );
+```
  */
-exports.useListItemRovingFocus = common_1.createElemPropsHook(useCursorListModel_1.useCursorListModel)(function (_a, ref, elemProps) {
-    var state = _a.state, events = _a.events, getId = _a.getId, navigation = _a.navigation;
-    if (elemProps === void 0) { elemProps = {}; }
-    // Tracks when this element has focus. If this item is removed while still focused, we have to
-    // inform the model to move the cursor to the next item.
-    var focusRef = react_1.default.useRef(false);
-    var getIdRef = react_1.default.useRef(getId);
+exports.useListItemRovingFocus = common_1.createElemPropsHook(useCursorListModel_1.useCursorListModel)((model, _ref, elemProps = {}) => {
     // Create a ref out of state. We don't want to watch state on unmount, so we use a ref to get the
     // current value at the time of unmounting. Otherwise, `state.items` would be a cached value of an
     // empty array
-    var stateRef = react_1.default.useRef(state);
-    stateRef.current = state;
-    var keyDownRef = react_1.default.useRef(false);
-    var isRTL = common_1.useIsRTL();
-    react_1.default.useEffect(function () {
-        if (keyDownRef.current) {
-            var item_1 = navigation.getItem(state.cursorId, { state: state });
-            if (state.isVirtualized) {
-                state.UNSTABLE_virtual.scrollToIndex(item_1.index);
+    const stateRef = react_1.default.useRef(model.state);
+    stateRef.current = model.state;
+    const keyElementRef = react_1.default.useRef(null);
+    const isRTL = common_1.useIsRTL();
+    react_1.default.useEffect(() => {
+        if (keyElementRef.current) {
+            const item = model.navigation.getItem(model.state.cursorId, model);
+            if (model.state.isVirtualized) {
+                model.state.UNSTABLE_virtual.scrollToIndex(item.index);
             }
-            requestAnimationFrame(function () {
-                var _a;
-                (_a = document
-                    .querySelector("[data-focus-id=\"" + (state.id + "-" + getIdRef.current(item_1)) + "\"]")) === null || _a === void 0 ? void 0 : _a.focus();
-            });
-            keyDownRef.current = false;
+            const selector = (id) => {
+                return document.querySelector(`[data-focus-id="${`${id}-${item.id}`}"]`);
+            };
+            // In React concurrent mode, there could be several render attempts before the element we're
+            // looking for could be available in the DOM
+            retryEachFrame(() => {
+                var _a, _b;
+                // Attempt to extract the ID from the DOM element. This fixes issues where the server and client
+                // do not agree on a generated ID
+                const clientId = (_b = (_a = keyElementRef.current) === null || _a === void 0 ? void 0 : _a.getAttribute('data-focus-id')) === null || _b === void 0 ? void 0 : _b.split('-')[0];
+                const element = selector(clientId) || selector(model.state.id);
+                element === null || element === void 0 ? void 0 : element.focus();
+                if (element) {
+                    keyElementRef.current = null;
+                }
+                return !!element;
+            }, 5); // 5 should be enough, right?!
         }
         // we only want to run this effect if the cursor changes and not any other time
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.cursorId]);
+    }, [model.state.cursorId]);
+    // Roving focus must always have a focus stop to function correctly
+    react_1.default.useEffect(() => {
+        if (!model.state.cursorId && model.state.items.length) {
+            model.events.goTo({ id: model.state.items[0].id });
+        }
+    }, [model.state.cursorId, model.state.items, model.events]);
     return {
-        onKeyDown: function (event) {
-            var _a;
-            // Test ctrl key first
-            if (event.ctrlKey) {
-                for (var key in ctrlKeyMap) {
-                    if (hasOwnKey(ctrlKeyMap, key)) {
-                        if (event.key === key) {
-                            keyDownRef.current = true;
-                            (_a = events[ctrlKeyMap[key]]) === null || _a === void 0 ? void 0 : _a.call(events);
-                            event.preventDefault();
-                            return;
-                        }
-                    }
-                }
+        onKeyDown(event) {
+            const handled = keyUtils_1.keyboardEventToCursorEvents(event, model, isRTL);
+            if (handled) {
+                event.preventDefault();
+                keyElementRef.current = event.currentTarget;
             }
-            // Try regular keys
-            keys(state.columnCount > 0 ? gridKeyMap : exports.orientationKeyMap[state.orientation]).forEach(function (key) {
-                var _a;
-                if (isRTL ? event.key === rightToLeftMap[key] : event.key === key) {
-                    var eventName = state.columnCount > 0 ? gridKeyMap[key] : exports.orientationKeyMap[state.orientation][key];
-                    keyDownRef.current = true;
-                    if (events[eventName]) {
-                        (_a = events[eventName]) === null || _a === void 0 ? void 0 : _a.call(events);
-                        event.preventDefault();
-                    }
-                }
-            });
-        },
-        onFocus: function () {
-            focusRef.current = true;
-        },
-        onBlur: function () {
-            focusRef.current = false;
         },
-        onClick: function () {
-            events.goTo({ id: elemProps['data-id'] });
+        onClick() {
+            model.events.goTo({ id: elemProps['data-id'] });
         },
-        'data-focus-id': state.id + "-" + elemProps['data-id'],
-        tabIndex: !state.cursorId
+        'data-focus-id': `${model.state.id}-${elemProps['data-id']}`,
+        tabIndex: !model.state.cursorId
             ? 0 // cursor isn't known yet, be safe and mark this as focusable
-            : !!elemProps['data-id'] && state.cursorId === elemProps['data-id']
+            : !!elemProps['data-id'] && model.state.cursorId === elemProps['data-id']
                 ? 0 // A name is known and cursor is here
-                : -1,
-        ref: ref,
+                : -1, // A name is known an cursor is somewhere else
     };
 });

package/dist/commonjs/collection/lib/useListItemSelect.d.ts

@@ -1,10 +1,26 @@
 import React from 'react';
-export declare const useListItemSelect: <P extends {}, R>(model: {
+/**
+ * This elemProps hook adds selection support to a `*.Item` subcomponent of a collection. It adds a
+ * click handler that toggles selection status according to the [Selection
+ * Manager](#selection-manager) used.
+ *
+ * ```ts
+ * const useMyItem = composeHooks(
+ *   useListItemSelect, // adds selection support to an item
+ *   useListItemRegister
+ * );
+ * ```
+ */
+export declare const useListItemSelect: import("@workday/canvas-kit-react/common").BehaviorHook<{
     state: {
-        selectedIds: import("./useSelectionListModel").SelectedIds;
+        selectedIds: string[] | "all";
         unselectedIds: string[];
         cursorId: string;
         columnCount: number;
+        pageSizeRef: React.MutableRefObject<number>;
+        cursorIndexRef: {
+            readonly current: number;
+        };
         UNSTABLE_virtual: {
             virtualItems: import("./react-virtual").VirtualItem[];
             totalSize: number;
@@ -15,7 +31,7 @@ export declare const useListItemSelect: <P extends {}, R>(model: {
         UNSTABLE_defaultItemHeight: number;
         containerRef: React.RefObject<HTMLDivElement>;
         id: string;
-        orientation: import("./useBaseListModel").Orientation;
+        orientation: "horizontal" | "vertical";
         indexRef: React.MutableRefObject<number>;
         nonInteractiveIds: string[];
         isVirtualized: boolean;
@@ -27,10 +43,6 @@ export declare const useListItemSelect: <P extends {}, R>(model: {
         }): void;
         selectAll(): void;
         unselectAll(): void;
-        registerItem(data: {
-            item: any;
-            textValue: string;
-        }): void;
         goTo(data: {
             id: string;
         }): void;
@@ -44,6 +56,10 @@ export declare const useListItemSelect: <P extends {}, R>(model: {
         goToLastOfRow(): void;
         goToNextPage(): void;
         goToPreviousPage(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
         unregisterItem(data: {
             id: string;
         }): void;
@@ -54,9 +70,7 @@ export declare const useListItemSelect: <P extends {}, R>(model: {
     selection: import("./useSelectionListModel").SelectionManager;
     navigation: import("./useCursorListModel").NavigationManager;
     getId: (item: any) => string;
-}, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => {
+}, {
     onClick: (event: React.MouseEvent<HTMLElement>) => void;
-} & P & (R extends HTMLOrSVGElement ? {
-    ref: React.Ref<R>;
-} : {});
+}>;
 //# sourceMappingURL=useListItemSelect.d.ts.map

package/dist/commonjs/collection/lib/useListItemSelect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useListItemSelect.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListItemSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGF,gBAAgB,CAAC,WAAW,CAAC;;;OAYxD,CAAC"}
+{"version":3,"file":"useListItemSelect.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListItemSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAGF,gBAAgB,CAAC,WAAW,CAAC;EAWxD,CAAC"}

package/dist/commonjs/collection/lib/useListItemSelect.js

@@ -1,18 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useListItemSelect = void 0;
-var common_1 = require("@workday/canvas-kit-react/common");
-var useListModel_1 = require("./useListModel");
-exports.useListItemSelect = common_1.createElemPropsHook(useListModel_1.useListModel)(function (_a, _, elemProps) {
-    var state = _a.state, events = _a.events;
-    if (elemProps === void 0) { elemProps = {}; }
-    var name = elemProps['data-id'] || '';
-    var onClick = function (event) {
-        if (state.nonInteractiveIds.includes(name) ||
-            event.currentTarget.hasAttribute('aria-disabled')) {
-            return;
+const common_1 = require("@workday/canvas-kit-react/common");
+const useListModel_1 = require("./useListModel");
+/**
+ * This elemProps hook adds selection support to a `*.Item` subcomponent of a collection. It adds a
+ * click handler that toggles selection status according to the [Selection
+ * Manager](#selection-manager) used.
+ *
+ * ```ts
+ * const useMyItem = composeHooks(
+ *   useListItemSelect, // adds selection support to an item
+ *   useListItemRegister
+ * );
+ * ```
+ */
+exports.useListItemSelect = common_1.createElemPropsHook(useListModel_1.useListModel)(({ state, events }, _, elemProps = {}) => {
+    const name = elemProps['data-id'] || '';
+    const onClick = (event) => {
+        if (!state.nonInteractiveIds.includes(name) &&
+            event.currentTarget.getAttribute('aria-disabled') !== 'true') {
+            events.select({ id: name });
         }
-        events.select({ id: name });
     };
-    return { onClick: onClick };
+    return { onClick };
 });

package/dist/commonjs/collection/lib/useListKeyboardHandler.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+/**
+ * This elemProps hook is used to attach keyboard events to handle keyboard navigation
+ *
+ * ```ts
+ * const useMyItem = composeHooks(
+ *   useListKeyboardHandler, // adds keyboard support support
+ *   useListItemRegister
+ * );
+```
+ */
+export declare const useListKeyboardHandler: import("@workday/canvas-kit-react/common").BehaviorHook<{
+    state: {
+        cursorId: string;
+        columnCount: number;
+        pageSizeRef: React.MutableRefObject<number>;
+        cursorIndexRef: {
+            readonly current: number;
+        };
+        UNSTABLE_virtual: {
+            virtualItems: import("./react-virtual").VirtualItem[];
+            totalSize: number;
+            scrollToOffset: (index: number, options?: import("./react-virtual").ScrollToOffsetOptions | undefined) => void;
+            scrollToIndex: (index: number, options?: import("./react-virtual").ScrollToIndexOptions | undefined) => void;
+            measure: () => void;
+        };
+        UNSTABLE_defaultItemHeight: number;
+        containerRef: React.RefObject<HTMLDivElement>;
+        id: string;
+        orientation: "horizontal" | "vertical";
+        indexRef: React.MutableRefObject<number>;
+        nonInteractiveIds: string[];
+        isVirtualized: boolean;
+        items: import("./useBaseListModel").Item<any>[];
+    };
+    events: {
+        goTo(data: {
+            id: string;
+        }): void;
+        goToNext(): void;
+        goToPrevious(): void;
+        goToPreviousRow(): void;
+        goToNextRow(): void;
+        goToFirst(): void;
+        goToLast(): void;
+        goToFirstOfRow(): void;
+        goToLastOfRow(): void;
+        goToNextPage(): void;
+        goToPreviousPage(): void;
+        registerItem(data: {
+            item: any;
+            textValue: string;
+        }): void;
+        unregisterItem(data: {
+            id: string;
+        }): void;
+        updateItemHeight(data: {
+            value: number;
+        }): void;
+    };
+    navigation: import("./useCursorListModel").NavigationManager;
+    getId: (item: any) => string;
+}, {
+    onKeyDown(event: React.KeyboardEvent): void;
+}>;
+//# sourceMappingURL=useListKeyboardHandler.d.ts.map

package/dist/commonjs/collection/lib/useListKeyboardHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListKeyboardHandler.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListKeyboardHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAId,mBAAmB;EAOtC,CAAC"}

package/dist/commonjs/collection/lib/useListKeyboardHandler.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListKeyboardHandler = void 0;
+const common_1 = require("@workday/canvas-kit-react/common");
+const useCursorListModel_1 = require("./useCursorListModel");
+const keyUtils_1 = require("./keyUtils");
+/**
+ * This elemProps hook is used to attach keyboard events to handle keyboard navigation
+ *
+ * ```ts
+ * const useMyItem = composeHooks(
+ *   useListKeyboardHandler, // adds keyboard support support
+ *   useListItemRegister
+ * );
+```
+ */
+exports.useListKeyboardHandler = common_1.createElemPropsHook(useCursorListModel_1.useCursorListModel)(model => {
+    const isRTL = common_1.useIsRTL();
+    return {
+        onKeyDown(event) {
+            const handled = keyUtils_1.keyboardEventToCursorEvents(event, model, isRTL);
+            if (handled) {
+                event.preventDefault();
+            }
+        },
+    };
+});

package/dist/commonjs/collection/lib/useListLoader.d.ts

@@ -0,0 +1,106 @@
+import { Model } from '@workday/canvas-kit-react/common';
+import { useListModel } from './useListModel';
+export interface LoadReturn<T> {
+    items: T[];
+    total?: number;
+}
+export interface LoadParams {
+    pageNumber: number;
+    pageSize: number;
+    filter: CollectionLoader['filter'];
+    sorter: CollectionLoader['sorter'];
+}
+export interface AsyncCollectionConfig<T, M extends Model<any, any>> {
+    /**
+     * The desired results per page.
+     */
+    pageSize: number;
+    /**
+     * The total items in the collection. If you do not have this information before making an API
+     * call, leave it blank and it will default to `0` and be updated when `load` comes back with
+     * results.
+     * @default 0
+     */
+    total?: number;
+    /**
+     * This function acts like a guard similar to model events. If you provide this function and it
+     * returns `false`, the `load` call from the loader will be cancelled. Be aware, this function can
+     * cause a loader to not function properly. You will need to call `loader.load(pageNumber)` on
+     * your own if a valid load event is cancelled. An example of using this function is in
+     * {@link useComboboxLoader} where the load calls are only allowed when the menu is open.
+     */
+    shouldLoad?(
+    /**
+     * Parameters that are being sent to the `load` function
+     */
+    params: LoadParams, 
+    /**
+     * State coming from the model
+     */
+    prevState: M['state']): boolean;
+    /**
+     * A `load` callback function provides an easier way to hook up loader requests for data to an
+     * API. It will be called when the user is ready for more of the virtual data set. The `load`
+     * function will be called when:
+     * - The list UI initially loads. It will request as many pages as necessary to render enough
+     *   items in the viewport
+     * - The user is scrolling the list and has run out of cached data
+     * - The user is using the keyboard to navigate the list and has run out of cached data
+     * - A filter or sorter value has changed and the cached data is now invalid
+     * - `loader.load` was called by the developer, manually requesting a page number
+     */
+    load(params: LoadParams): LoadReturn<T> | Promise<LoadReturn<T>>;
+}
+export interface CollectionLoader {
+    filter: string | Record<string, string>;
+    updateFilter(value: string): void;
+    sorter: string | Record<string, string>;
+    updateSorter(value: string): void;
+    isLoading: boolean;
+    load(pageNumber?: number): void;
+}
+export declare function getPageNumber(index: number, pageSize: number): number;
+/**
+ *
+ * @param start The start index of the virtual window
+ * @param end The end index of the virtual window
+ * @param pageSize Expected load page size
+ * @param items Sparse array of all loaded items
+ * @param overScan How many items ahead we want to look ahead to trigger loading. Unloaded items
+ * that are this many items outside the current start and end numbers will trigger a loading of
+ * a page
+ */
+export declare function getPagesToLoad<T>(start: number, end: number, pageSize: number, items: T[], overScan?: number): number[];
+/**
+ * Create a data loader and a model. The list loader should be used on virtual data sets with
+ * possibly large amounts of data. The model should be passed to a collection component. The loader
+ * can be used to manipulate filters, sorters, and clear cache.
+ *
+ * A simple loader using [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) could
+ * look like the following:
+ *
+ * ```ts
+ * const {model, loader} = useListLoader(
+ *   {
+ *     total: 1000,
+ *     pageSize: 20,
+ *     async load({pageNumber, pageSize}) {
+ *       return fetch('/myUrl')
+ *         .then(response => response.json())
+ *         .then(response => {
+ *           return {total: response.total, items: response.items};
+ *         });
+ *     },
+ *   },
+ *   useListModel
+ * );
+ * ```
+ *
+ * @param config Config that contains the loader config and the model config
+ * @param modelHook A model hook that describes which model should be returned.
+ */
+export declare function useListLoader<T, M extends ((...args: any[]) => any) & Omit<typeof useListModel, 'Context'>>(config: AsyncCollectionConfig<T, ReturnType<M>> & M['TConfig'], modelHook: M): {
+    model: ReturnType<M>;
+    loader: CollectionLoader;
+};
+//# sourceMappingURL=useListLoader.d.ts.map

package/dist/commonjs/collection/lib/useListLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useListLoader.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useListLoader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,EAAC,MAAM,kCAAkC,CAAC;AAEvD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;CACpC;AACD,MAAM,WAAW,qBAAqB,CAAC,CAAC,EAAE,CAAC,SAAS,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC;IACjE;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,UAAU,CAAC;IACT;;OAEG;IACH,MAAM,EAAE,UAAU;IAClB;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GACpB,OAAO,CAAC;IACX;;;;;;;;;;OAUG;IACH,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AA8CD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAM5D;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,SAAI,GACX,MAAM,EAAE,CAkBV;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAED,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,YAAY,EAAE,SAAS,CAAC,EAE1E,MAAM,EAAE,qBAAqB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,EAC9D,SAAS,EAAE,CAAC,GACX;IAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAC,CAgLlD"}