@workday/canvas-kit-react 6.8.10 → 6.9.0-next.3

package/ts3.5/dist/es6/common/lib/utils/colorUtils.d.ts

@@ -1,11 +0,0 @@
-export declare const expandHex: (hex: string) => string;
-/**
- *
- * Chooses foreground color with accesible contrast against background. If contrast ratio
- * is greater than 4.5:1, chooses provided light or dark color (favoring light color). If neither
- * have a high enough contrast ratio, picks the first color of the following that meets 4.5:1 or higher:
- * [frenchVanilla100, blackPepper300, blackPepper400, blackPepper500, blackPepper600]
- * (https://www.w3.org/TR/WCAG20-TECHS/G18.html)
- */
-export declare const pickForegroundColor: (background: string, darkColor?: string | undefined, lightColor?: string | undefined) => string | undefined;
-//# sourceMappingURL=colorUtils.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/components.d.ts

@@ -1,278 +0,0 @@
-import React from 'react';
-import { Model } from './models';
-/**
- * Adds the `as` to the style interface to support `as` in styled components
- * This type and usage should be removed with Emotion 11
- */
-export declare type StyledType = {
-    as?: React.ElementType;
-};
-/**
- * Extract a Ref from T if it exists
- * This will return the following:
- *
- * - `undefined` => `never`
- * - `'button'` => `React.Ref<HTMLButtonElement>`
- * - `ElementComponent<'button', ButtonProps>` => `React.Ref<HTMLButtonElement>`
- */
-declare type ExtractRef<T> = T extends undefined ? never : React.Ref<T extends keyof ElementTagNameMap ? ElementTagNameMap[T] : T extends ElementComponent<infer U, any> ? U extends keyof ElementTagNameMap ? ElementTagNameMap[U] : U : T>;
-/**
- * Generic component props with "as" prop
- * @template P Additional props
- * @template ElementType React component or string element
- */
-export declare type PropsWithAs<P, ElementType extends React.ElementType> = P & Pick<React.ComponentProps<ElementType>, Exclude<keyof React.ComponentProps<ElementType>, 'as' | 'state' | keyof P>> & {
-    /**
-     * Optional ref. If the component represents an element, this ref will be a reference to the
-     * real DOM element of the component. If `as` is set to an element, it will be that element.
-     * If `as` is a component, the reference will be to that component (or element if the component
-     * uses `React.forwardRef`).
-     */
-    ref?: ExtractRef<ElementType>;
-};
-/**
- * Extracts only the HTML attribute interface from `JSX.IntrinsicElements[E]`. This effectively removes `ref` and `key`
- * without using `Omit` which makes the returned type more difficult to understand.
- *
- * For example:
- * JSX.IntrinsicElements['button'] // React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement>
- * ExtractHTMLAttributes<JSX.IntrinsicElements['button']> // React.HTMLButtonAttributes<HTMLButtonElement>
- */
-declare type ExtractHTMLAttributes<T extends React.DetailedHTMLProps<any, any>> = T extends React.DetailedHTMLProps<infer P, any> ? P : T;
-/**
- * Extract props from any component that was created using `createComponent`. It will return the
- * HTML attribute interface of the default element used with `createComponent`. If you use `as`, the
- * HTML attribute interface can change, so you can use an override to the element you wish to use.
- * You can also disable the HTML attribute by passing `never`:
- *
- * - `ExtractProps<typeof Card>`: `CardProps & React.HTMLAttributes<HTMLDivElement>`
- * - `ExtractProps<typeof Card, 'aside'>`: `CardProps & React.HTMLAttributes<HTMLElement>`
- * - `ExtractProps<typeof Card, never>`: `CardProps`
- *
- * @template TComponent The component you wish to extract props from. Needs 'typeof` in front:
- * `typeof Card`
- * @template TElement An optional override of the element that will be used. Define this if you use
- * an `as` on the component
- *
- * @example
- * interface MyProps extends ExtractProps<typeof Card.Body> {}
- *
- * ExtractProps<typeof Card>; // CardProps & React.HTMLAttributes<HTMLDivElement>
- * ExtractProps<typeof Card, 'aside'>; // CardProps & React.HTMLAttributes<HTMLElement>
- * ExtractProps<typeof Card, never>; // CardProps
- */
-export declare type ExtractProps<TComponent, TElement extends keyof JSX.IntrinsicElements | ElementComponent<any, any> | Component<any> | React.ComponentType<any> | undefined | never = undefined> = TComponent extends ElementComponent<infer E, infer P> ? [TElement] extends [never] ? P : TElement extends undefined ? E extends keyof JSX.IntrinsicElements ? P & ExtractHTMLAttributes<JSX.IntrinsicElements[E]> : P & ExtractPropsFromComponent<E> : TElement extends keyof JSX.IntrinsicElements ? P & ExtractHTMLAttributes<JSX.IntrinsicElements[TElement]> : P & ExtractPropsFromComponent<TElement> : ExtractPropsFromComponent<TComponent>;
-declare type ExtractPropsFromComponent<TComponent> = TComponent extends ElementComponent<infer E, infer P> ? E extends keyof JSX.IntrinsicElements ? P & ExtractHTMLAttributes<JSX.IntrinsicElements[E]> : P : TComponent extends Component<infer P> ? P : TComponent extends React.ComponentType<infer P> ? P : {};
-/**
- * Component type that allows for `as` to change the element or component type.
- * Passing `as` will correctly change the allowed interface of the JSX element
- */
-export declare type ElementComponent<T extends React.ElementType, P> = {
-    __type: 'ElementComponent';
-    <ElementType extends React.ElementType>(props: PropsWithAs<P, ElementType> & {
-        /**
-         * Optional override of the default element used by the component. Any valid tag or Component.
-         * If you provided a Component, this component should forward the ref using `React.forwardRef`
-         * and spread extra props to a root element.
-         */
-        as: ElementType;
-    }): JSX.Element;
-    (props: PropsWithAs<P, T>): JSX.Element;
-    displayName?: string;
-    as<E extends React.ElementType>(as: E): ElementComponent<E, P>;
-};
-export declare type Component<P> = {
-    __type: 'Component';
-    (props: P): JSX.Element;
-    displayName?: string;
-};
-interface RefForwardingComponent<T, P = {}> {
-    (props: React.PropsWithChildren<P> & {
-        as?: React.ReactElement<any>;
-    }, 
-    /**
-     * A ref to be forwarded. Pass it along to the root element. If no element was passed, this
-     * will result in a `never`
-     */
-    ref: ExtractRef<T>, 
-    /**
-     * An element - either a JSX element or a `ElementComponent`. This should be passed as an `as`
-     * to a root element or be the root element. If no element was passed, this will result in a
-     * `never`
-     */
-    Element: T extends undefined ? never : T): React.ReactElement | null;
-}
-/**
- * Factory function that creates components to be exported. It enforces React ref forwarding, `as`
- * prop, display name, and sub-components, and handles proper typing without much boiler plate. The
- * return type is `Component<element, Props>` which looks like `Component<'div', Props>` which is a
- * clean interface that tells you the default element that is used.
- */
-export declare const createComponent: <E extends "symbol" | "object" | "button" | "meter" | "textarea" | "style" | "progress" | "text" | "ruby" | "table" | "small" | "sub" | "circle" | "embed" | "pre" | "caption" | "menu" | "menuitem" | "clipPath" | "filter" | "mask" | "marker" | "big" | "link" | "sup" | "a" | "abbr" | "address" | "area" | "article" | "aside" | "audio" | "b" | "base" | "bdi" | "bdo" | "blockquote" | "body" | "br" | "canvas" | "cite" | "code" | "col" | "colgroup" | "data" | "datalist" | "dd" | "del" | "details" | "dfn" | "dialog" | "div" | "dl" | "dt" | "em" | "fieldset" | "figcaption" | "figure" | "footer" | "form" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "header" | "hgroup" | "hr" | "html" | "i" | "iframe" | "img" | "input" | "ins" | "kbd" | "keygen" | "label" | "legend" | "li" | "main" | "map" | "mark" | "meta" | "nav" | "noindex" | "noscript" | "ol" | "optgroup" | "option" | "output" | "p" | "param" | "picture" | "q" | "rp" | "rt" | "s" | "samp" | "slot" | "script" | "section" | "select" | "source" | "span" | "strong" | "summary" | "template" | "tbody" | "td" | "tfoot" | "th" | "thead" | "time" | "title" | "tr" | "track" | "u" | "ul" | "var" | "video" | "wbr" | "webview" | "svg" | "animate" | "animateMotion" | "animateTransform" | "defs" | "desc" | "ellipse" | "feBlend" | "feColorMatrix" | "feComponentTransfer" | "feComposite" | "feConvolveMatrix" | "feDiffuseLighting" | "feDisplacementMap" | "feDistantLight" | "feDropShadow" | "feFlood" | "feFuncA" | "feFuncB" | "feFuncG" | "feFuncR" | "feGaussianBlur" | "feImage" | "feMerge" | "feMergeNode" | "feMorphology" | "feOffset" | "fePointLight" | "feSpecularLighting" | "feSpotLight" | "feTile" | "feTurbulence" | "foreignObject" | "g" | "image" | "line" | "linearGradient" | "metadata" | "mpath" | "path" | "pattern" | "polygon" | "polyline" | "radialGradient" | "rect" | "stop" | "switch" | "textPath" | "tspan" | "use" | "view" | ElementComponent<any, any> | React.ComponentClass<{}, any> | React.FunctionComponent<{}> | undefined = undefined>(as?: E | undefined) => <P, SubComponents = {}>({ displayName, Component, subComponents, }: {
-    /** This is what the component will look like in the React dev tools. Encouraged to more easily
-     * understand the component tree */
-    displayName?: string | undefined;
-    /** The component function. The function looks like:
-     * @example
-     * Component: ({children}, ref, Element) {
-     *   // `Element` is what's passed to the `as` of your component. If no `as` was defined, it
-     *   // will be the default element. It will be 'div' or even a another Component!
-     *   return (
-     *     <Element ref={ref}>{children}</Element>
-     *   )
-     * }
-     *
-     * @example
-     * Component: ({children}, ref, Element) {
-     *   // `Element` can be passed via `as` to the next component
-     *   return (
-     *     <AnotherElement as={Element} ref={ref}>{children}</AnotherElement>
-     *   )
-     * }
-     */
-    Component: RefForwardingComponent<E, P>;
-    /**
-     * Used in container components
-     */
-    subComponents?: SubComponents | undefined;
-}) => (E extends undefined ? Component<P> : ElementComponent<E extends undefined ? React.FC<{}> : E, P>) & SubComponents;
-/**
- * Factory function to crate a behavior hook with correct generic types. It takes a function that
- * return props and returns a function that will also require `elemProps` and will call `mergeProps` for
- * you. If your hook makes use of the `ref`, you will have to also use `useLocalRef` to properly fork
- * the ref.
- *
- * @example
- * const useMyHook = createHook((model: MyModel, ref) => {
- *   const { localRef, elementRef } = useLocalRef(ref);
- *   // do whatever with `localRef` which is a RefObject
- *
- *   return {
- *     onClick: model.events.doSomething,
- *     ref: elementRef,
- *   };
- * });
- *
- * // Equivalent to:
- * const useMyHook = <P extends {}, R>(
- *   model: MyModel,
- *   elemProps: P,
- *   ref: React.Ref<R>
- * ) => {
- *   const { localRef, elementRef } = useLocalRef(ref);
- *   // do whatever with `localRef` which is a RefObject
- *
- *   return mergeProps({
- *     onClick: model.events.doSomething,
- *     ref: elementRef,
- *   }, elemProps);
- * };
- *
- * @param fn Function that takes a model and optional ref and returns props
- */
-export declare const createHook: <M extends Model<any, any>, PO extends {}, PI extends {}>(fn: (model: M, ref?: ((instance: any) => void) | React.RefObject<any> | null | undefined, elemProps?: PI | undefined) => PO) => <P extends {}, R>(model: M, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => PO & P & (R extends HTMLOrSVGElement ? {
-    ref: React.Ref<R>;
-} : {});
-export declare const subModelHook: <M extends Model<any, any>, SM extends Model<any, any>, O extends {}>(fn: (model: M) => SM, hook: <P extends {}, R>(model: SM, elemProps?: P | undefined, ref?: ((instance: R | null) => void) | React.RefObject<R> | null | undefined) => O & P & (R extends HTMLOrSVGElement ? {
-    ref: React.Ref<R>;
-} : {})) => <P_1 extends {}, R_1>(model: M, elemProps?: P_1 | undefined, ref?: ((instance: R_1 | null) => void) | React.RefObject<R_1> | null | undefined) => O & P_1 & (R_1 extends HTMLOrSVGElement ? {
-    ref: React.Ref<R_1>;
-} : {});
-export declare type BehaviorHook<M extends Model<any, any>, O extends {}> = {
-    bivarianceHack<P extends {}, R>(model: M, elemProps?: P, ref?: React.Ref<R>): O & P & (R extends HTMLOrSVGElement ? {
-        ref: React.Ref<R>;
-    } : {});
-}['bivarianceHack'];
-/**
- * This function will create a new forked ref out of two input Refs. This is useful for components
- * that use `React.forwardRef`, but also need internal access to a Ref.
- *
- * This function is inspired by https://www.npmjs.com/package/@rooks/use-fork-ref
- *
- * @example
- * React.forwardRef((props, ref) => {
- *   // Returns a RefObject with a `current` property
- *   const myRef = React.useRef(ref)
- *
- *   // Returns a forked Ref function to pass to an element.
- *   // This forked ref will update both `myRef` and `ref` when React updates the element ref
- *   const elementRef = useForkRef(ref, myRef)
- *
- *   useEffect(() => {
- *     console.log(myRef.current) // `current` is the DOM instance
- *     // `ref` might be null since it depends on if someone passed a `ref` to your component
- *     // `elementRef` is a function and we cannot get a current value out of it
- *   })
- *
- *   return <div ref={elementRef}/>
- * })
- */
-export declare function useForkRef<T>(ref1?: React.Ref<T>, ref2?: React.Ref<T>): React.RefCallback<T>;
-/**
- * This functions handles the common use case where a component needs a local ref and needs to
- * forward a ref to an element.
- * @param ref The React ref passed from the `createComponent` factory function
- *
- * @example
- * const MyComponent = ({children, ...elemProps}: MyProps, ref, Element) => {
- *   const { localRef, elementRef } = useLocalRef(ref);
- *
- *   // do something with `localRef` which is a `RefObject` with a `current` property
- *
- *   return <Element ref={elementRef} {...elemProps} />
- * }
- */
-export declare function useLocalRef<T>(ref?: React.Ref<T>): {
-    localRef: React.RefObject<T>;
-    elementRef: (instance: T | null) => void;
-};
-/**
- * Returns a model, or calls the model hook with config. Clever way around the conditional React
- * hook ESLint rule.
- * @param model A model, if provided
- * @param config Config for a model
- * @param modelHook A model hook that takes valid config
- * @example
- * const ContainerComponent = ({children, model, ...config}: ContainerProps) => {
- *   const value = useDefaultModel(model, config, useContainerModel);
- *
- *   // ...
- * }
- */
-export declare function useDefaultModel<T, C>(model: T | undefined, config: C, modelHook: (config: C) => T): T;
-/**
- * Returns a model, or returns a model context. Clever way around the conditional React hook ESLint
- * rule
- * @param model A model, if provided
- * @param context The context of a model
- * @example
- * const SubComponent = ({children, model, ...elemProps}: SubComponentProps, ref, Element) => {
- *   const {state, events} = useModelContext(model, SubComponentModelContext);
- *
- *   // ...
- * }
- */
-export declare function useModelContext<T>(context: React.Context<T>, model?: T): T;
-/**
- * Compose many hooks together. Assumes hooks are using `mergeProps`. Returns a function that will
- * receive a model and return props to be applied to a component. These props should always be
- * applied last on the Component. The props will override as follows: rightmost hook props override
- * leftmost hook props which are overridden by props passed to the composeHooks function.
- *
- * A `ref` should be passed for hooks that require a ref. Each hook should fork the ref using
- * `useLocalRef`, passing the `elementRef` in the returned props object. This ref will be passed to
- * the next hook.
- *
- * @example
- * const MyComponent = React.forwardRef(({ children, model, ...elemProps }, ref) => {
- *   const props = composeHooks(useHook1, useHook2)(model, elemProps, ref)
- *
- *   return <div id="foo" {...props}>{children}</div>
- * })
- */
-export declare function composeHooks<M extends Model<any, any>, O1 extends {}, O2 extends {}>(hook1: BehaviorHook<M, O1>, hook2: BehaviorHook<M, O2>): BehaviorHook<M, O1 & O2>;
-export declare function composeHooks<M extends Model<any, any>, R, P extends {}, O1 extends {}, O2 extends {}, O3 extends {}>(hook1: BehaviorHook<M, O1>, hook2: BehaviorHook<M, O2>, hook3: BehaviorHook<M, O3>): BehaviorHook<M, O1 & O2 & O3>;
-export declare function composeHooks<M extends Model<any, any>, R, P extends {}, O1 extends {}, O2 extends {}, O3 extends {}, O4 extends {}>(hook1: BehaviorHook<M, O1>, hook2: BehaviorHook<M, O2>, hook3: BehaviorHook<M, O3>, hook4: BehaviorHook<M, O4>): BehaviorHook<M, O1 & O2 & O3 & O4>;
-export declare function composeHooks<M extends Model<any, any>, R, P extends {}, O1 extends {}, O2 extends {}, O3 extends {}, O4 extends {}, O5 extends {}>(hook1: BehaviorHook<M, O1>, hook2: BehaviorHook<M, O2>, hook3: BehaviorHook<M, O3>, hook4: BehaviorHook<M, O4>, hook5: BehaviorHook<M, O5>): BehaviorHook<M, O1 & O2 & O3 & O4 & O5>;
-export {};
-//# sourceMappingURL=components.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/elements.d.ts

@@ -1,14 +0,0 @@
-/**
- * Is an element focusable? This function performs various tests to see if the element in question
- * can receive focus. Should skip disabled elements as they are not focusable.
- */
-export declare const isFocusable: (element: HTMLElement) => boolean | null;
-/**
- * Get the first focusable element in a container.
- */
-export declare const getFirstFocusableElement: (container: HTMLElement) => HTMLElement | null;
-/**
- * Get the last focusable element in a container.
- */
-export declare const getLastFocusableElement: (container: HTMLElement) => HTMLElement | null;
-//# sourceMappingURL=elements.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/getTranslateFromOrigin.d.ts

@@ -1,12 +0,0 @@
-import { TransformOrigin } from '../types';
-/**
- * Gets the x and y distance values needed to translate from a given transform origin to 0,0
- * @param {Object} transformOrigin The origin of the transform (i.e. top left)
- * @param {string} distance The distance to translate (as a canvas spacing value).
- * @returns {Object} An object with the x and y distance values needed to translate.
- */
-export declare const getTranslateFromOrigin: (transformOrigin: TransformOrigin, distance: "0px" | "4px" | "8px" | "12px" | "16px" | "24px" | "32px" | "40px" | "64px" | "80px") => {
-    x: number;
-    y: number;
-};
-//# sourceMappingURL=getTranslateFromOrigin.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/index.d.ts

@@ -1,18 +0,0 @@
-export * from './colorUtils';
-export * from './getTranslateFromOrigin';
-export * from './changeFocus';
-export * from './makeMq';
-export * from './mergeCallback';
-export * from './mergeProps';
-export * from './useUniqueId';
-export * from './assert';
-export * from './useMount';
-export * from './components';
-export * from './models';
-export * from './elements';
-export * from './useConstant';
-export * from './useIsFullscreen';
-export * from './useWindowSize';
-export * from './useResizeObserver';
-export * from './StaticStates';
-//# sourceMappingURL=index.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/makeMq.d.ts

@@ -1,12 +0,0 @@
-/**
- * Generates a media queries given a set of named breakpoints
- * @param {Object} breakpoints Object of key-value pairs where the key is the name of
- * the breakpoint size and the value is the min-width of that breakpoint
- * @returns {Object} A set of CSS media queries for each breakpoint size
- */
-export declare const makeMq: (breakpoints: {
-    [key: string]: number;
-}) => {
-    [key: string]: string;
-};
-//# sourceMappingURL=makeMq.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/mergeCallback.d.ts

@@ -1,15 +0,0 @@
-/**
- * Merge callbacks by returning a function that calls both functions. This is useful for components
- * that need to provide callback functionality, but want to allow additional functionality to be
- * provided
- * @example
- * const MyComponent = ({ myProp, ...elemProps }) => {
- *   return (
- *     <button onClick={mergeCallback(cb, elemProps.onClick)}>Click Me</button>
- *   )
- * }
- * @param elemProps Props passed into a component
- * @param componentProps Props the component provides
- */
-export declare function mergeCallback<T extends Function>(callback1: T, callback2?: Function): T;
-//# sourceMappingURL=mergeCallback.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/mergeProps.d.ts

@@ -1,6 +0,0 @@
-/**
- * Merges source props into target props, overwriting target props that are also defined on source
- * props. Callback will be merged in such a way that both callbacks will be called.
- */
-export declare function mergeProps<T extends object, S extends object>(targetProps: T, sourceProps: S): S & T;
-//# sourceMappingURL=mergeProps.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/models.d.ts

@@ -1,107 +0,0 @@
-export declare type Model<State, Events extends IEvent> = {
-    state: State;
-    events: Events;
-};
-declare type IEvent = {
-    [key: string]: {
-        bivarianceHack(data?: object): void;
-    }['bivarianceHack'];
-};
-/**
- * A mapping of guards and callbacks and what events they relate to.
- * @template TEvents The model events
- * @template TGuardMap A mapping of guards to events they're associated with
- * @template TCallbackMap A mapping of callbacks to events they're associated with
- */
-declare type EventMap<TEvents extends IEvent, TGuardMap extends Record<string, keyof TEvents>, TCallbackMap extends Record<string, keyof TEvents>> = {
-    guards: TGuardMap;
-    callbacks: TCallbackMap;
-};
-declare type ToGuardConfig<TState extends Record<string, any>, TEvents extends IEvent, TGuardMap extends Record<string, keyof TEvents>> = {
-    [K in keyof TGuardMap]: (event: {
-        data: Parameters<TEvents[TGuardMap[K]]>[0];
-        state: TState;
-    }) => boolean;
-};
-declare type ToCallbackConfig<TState extends Record<string, any>, TEvents extends IEvent, TCallbackMap extends Record<string, keyof TEvents>> = {
-    [K in keyof TCallbackMap]: (event: {
-        data: Parameters<TEvents[TCallbackMap[K]]>[0];
-        /**
-         * Callbacks are called during the `setState` phase in React. This means the state has not
-         * resolved yet. This is a good time to add more `setState` calls which will be added to React's
-         * state batch updates, but it also means the state provided here hasn't been updated yet.
-         */
-        prevState: TState;
-    }) => void;
-};
-/**
- * Takes the State and Events of a model along with the event map and creates a model config type that is used
- * to configure the model.
- *
- * @example
- * type ModelConfig = {
- *   // additional config your model requires goes here
- *   id?: string
- * } & Partial<ToModelConfig<State, Events, typeof eventMap>>
- */
-export declare type ToModelConfig<TState extends Record<string, any>, TEvents extends IEvent, TEventMap extends EventMap<TEvents, any, any>> = ToGuardConfig<TState, TEvents, TEventMap['guards']> & ToCallbackConfig<TState, TEvents, TEventMap['callbacks']>;
-/**
- * Convenience factory function that extracts type information and encodes it for use with model
- * config and `useEventMap`. Under the hood, it returns the config that was passed in. The real
- * magic is in type extraction and encoding which reduces boilerplate.
- *
- * `createEventMap` is a function that takes an `Events` generic and will return a function that
- * takes in a config object to configure all guards and callbacks. The empty function is used because
- * Typescript does not allow partial specification of generics (either you specify all generics or
- * none of them). Since `Events` cannot be inferred, it is passed to the first function.
- *
- * @example
- * type Events = {
- *   open(data: { eventData: string }): void
- * }
- *
- * const eventMap = createEventMap<Events>()({
- *   guards: {
- *     shouldOpen: 'open'
- *   },
- *   callbacks: {
- *     onOpen: 'open'
- *   }
- * })
- */
-export declare const createEventMap: <TEvents extends IEvent>() => <TGuardMap extends Record<string, keyof TEvents>, TCallbackMap extends Record<string, keyof TEvents>>(config: Partial<EventMap<TEvents, TGuardMap, TCallbackMap>>) => EventMap<TEvents, TGuardMap, TCallbackMap>;
-/**
- * This hook creates a stable reference events object to be used in a model. The reference is stable
- * by the use of `React.Memo` and uses React Refs to make sure there are no stale closure values. It
- * takes in an event map, state, model config, and an events object. It will map over each event and
- * add guards and callbacks to the event as configured in the event map.
- *
- * @param eventMap
- * @param state
- * @param config
- * @param events
- *
- * @example
- * const useDiscloseModel = (config: ModelConfig = {}): DiscloseModel => {
- *   const events = useEventMap(eventMap, state, config, {
- *     open() {
- *       // do something
- *     }
- *   }
- * })
- */
-export declare const useEventMap: <TEvents extends IEvent, TState extends Record<string, any>, TGuardMap extends Record<string, keyof TEvents>, TCallbackMap extends Record<string, keyof TEvents>, TConfig extends Partial<ToModelConfig<TState, TEvents, EventMap<TEvents, TGuardMap, TCallbackMap>>>>(eventMap: EventMap<TEvents, TGuardMap, TCallbackMap>, state: TState, config: TConfig, events: TEvents) => TEvents;
-declare type EventCreator = {
-    [key: string]: {
-        bivarianceHack(...args: any[]): object;
-    }['bivarianceHack'];
-};
-declare type ToEvent<TEvents extends EventCreator> = {
-    [K in keyof TEvents]: (data: ReturnType<TEvents[K]>) => void;
-};
-export declare const createEvents: <TEvents extends EventCreator>(events: TEvents) => <TGuardMap extends Record<string, keyof TEvents>, TCallbackMap extends Record<string, keyof TEvents>>(config?: Partial<EventMap<ToEvent<TEvents>, TGuardMap, TCallbackMap>> | undefined) => {
-    events: TEvents;
-    eventMap: EventMap<ToEvent<TEvents>, TGuardMap, TCallbackMap>;
-};
-export {};
-//# sourceMappingURL=models.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useConstant.d.ts

@@ -1,9 +0,0 @@
-/**
- * Get a constant value in React, only running the callback function once.  `React.useMemo` does not
- * guarantee that a function will only be run once.
- *
- * @example
- * const value = useConstant(generateUniqueId)
- */
-export declare function useConstant<T>(fn: () => T): T;
-//# sourceMappingURL=useConstant.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useIsFullscreen.d.ts

@@ -1,2 +0,0 @@
-export declare const useIsFullscreen: () => boolean;
-//# sourceMappingURL=useIsFullscreen.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useMount.d.ts

@@ -1,11 +0,0 @@
-/**
- * Alias to `useEffect` with the intention to only run on mount/unmount.
- * Avoids the React lint errors and encodes intent.
- */
-export declare const useMount: (callback: () => void | (() => void)) => void;
-/**
- * Alias to `useLayoutEffect` with the intention to only run on mount/unmount
- * Avoids the React lint errors and encodes intent.
- */
-export declare const useMountLayout: (callback: () => void | (() => void)) => void;
-//# sourceMappingURL=useMount.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useResizeObserver.d.ts

@@ -1,3 +0,0 @@
-import useResizeObserverOriginal from 'use-resize-observer';
-export declare const useResizeObserver: typeof useResizeObserverOriginal;
-//# sourceMappingURL=useResizeObserver.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useUniqueId.d.ts

@@ -1,41 +0,0 @@
-/**
- * Generates a unique and HTML5 compliant identifier every time it is called. Internally it uses a 4
- * character random seed starting with a letter. This seed is unique to each instance of this
- * package meaning different versions of Canvas Kit on the page will have a different seed. Each
- * call will use a Base 36 string (10 numbers + 26 letters) based on an incremented number. The
- * incremented number always starts at 0 and can be reset for testing purposes using
- * [resetUniqueIdCount](#resetuniqueidcount). [setUniqueSeed](#setuniqueseed) can also be used for
- * testing or server side rendering to get the same results during hydration.
- */
-export declare const generateUniqueId: () => string;
-/**
- * Generate a unique ID if one is not provided. The generated ID will be stable across renders
- * @param id Optional ID provided that will be used instead of a unique ID
- */
-export declare const useUniqueId: (id?: string | undefined) => string;
-/**
- * Backwards-compatible change to converting to hook
- * @deprecated
- * TODO: Remove in major release
- */
-export declare const uniqueId: (id?: string | undefined) => string;
-/**
- * Update the seed used by the id generator. This is useful for snapshot tests to help stabilize ids
- * generated each run. This could also be used for server-side hydration - if you choose the same
- * seed for server and set that on the client before components are rendered, the ids generated will
- * be the same.
- * @example
- * // set in a script tag from the server
- * setSeed(window.__ID_SEED); // set in a script tag from the server
- *
- * // jest setup
- * before(() => {
- *   setSeed('a')
- * })
- */
-export declare const setUniqueSeed: (s: string) => void;
-/**
- * This should only be called for tests in an `beforeEach`
- */
-export declare const resetUniqueIdCount: () => void;
-//# sourceMappingURL=useUniqueId.d.ts.map

package/ts3.5/dist/es6/common/lib/utils/useWindowSize.d.ts

@@ -1,5 +0,0 @@
-export declare const useWindowSize: () => {
-    width: number;
-    height: number;
-};
-//# sourceMappingURL=useWindowSize.d.ts.map

package/ts3.5/dist/es6/cookie-banner/index.d.ts

@@ -1,5 +0,0 @@
-import DeprecatedCookieBanner from './lib/CookieBanner';
-export default DeprecatedCookieBanner;
-export { DeprecatedCookieBanner };
-export * from './lib/CookieBanner';
-//# sourceMappingURL=index.d.ts.map

package/ts3.5/dist/es6/cookie-banner/lib/CookieBanner.d.ts

@@ -1,48 +0,0 @@
-import * as React from 'react';
-/**
- * ### Deprecated Cookie Banner Props
- *
- * As of Canvas Kit v6, CookieBanner is being soft-deprecated.
- * It will be hard-deprecated (completely removed) in v7. Please see the
- * [migration guide](https://workday.github.io/canvas-kit/?path=/story/welcome-migration-guides-v6-0--page)
- * for more information.
- */
-export interface DeprecatedCookieBannerProps {
-    /**
-     * If true, set the CookieBanner to the closed state.
-     * @default false
-     */
-    isClosed?: boolean;
-    /**
-     * The function called when cookies are accepted via the CookieBanner. This callback function should set `isClosed` to `true`.
-     */
-    onAccept: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    /**
-     * The function called when the CookieBanner settings button is clicked. The settings button is automatically displayed if this callback function is provided.
-     */
-    onClickSettings?: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    /**
-     * The notice text or element of the CookieBanner.
-     * @default CookieBanner.DefaultNotice
-     */
-    notice?: string | React.ReactNode;
-    /**
-     * The text of the CookieBanner settings button.
-     * @default 'Cookie Settings'
-     */
-    settingsLabel?: string;
-}
-/**
- * ### Deprecated Cookie Banner
- *
- * As of Canvas Kit v6, this component is being soft-deprecated.
- * It will be hard-deprecated (completely removed) in v7. Please see the
- * [migration guide](https://workday.github.io/canvas-kit/?path=/story/welcome-migration-guides-v6-0--page)
- * for more information.
- */
-export default class DeprecatedCookieBanner extends React.Component<DeprecatedCookieBannerProps> {
-    componentDidMount(): void;
-    static DefaultNotice: string;
-    render(): React.ReactNode;
-}
-//# sourceMappingURL=CookieBanner.d.ts.map

package/ts3.5/dist/es6/dialog/index.d.ts

@@ -1,3 +0,0 @@
-export * from './lib/Dialog';
-export * from './lib/hooks';
-//# sourceMappingURL=index.d.ts.map