@workday/canvas-kit-react 10.0.0-alpha.540-next.0 → 10.0.0-alpha.543-next.0

package/common/lib/utils/models.ts

@@ -2,7 +2,7 @@
 import React from 'react';
 
 /**
- * @deprecated ⚠️ `Model` has been deprecated and will be removed in a future major version. The returned model is now inferred from `createModelHook`.
+ * @deprecated The returned model is now inferred from `createModelHook`
  */
 export type Model<State, Events extends IEvent> = {
   state: State;
@@ -64,7 +64,7 @@ type ToCallbackConfig<
  *   id?: string
  * } & Partial<ToModelConfig<State, Events, typeof eventMap>>
  *
- * @deprecated ⚠️ `ToModelConfig` has been deprecated and will be removed in a future major version. Please use `createModelHook` instead since it infers the config type.
+ * @deprecated `createModelHook` now infers the config type
  */
 export type ToModelConfig<
   TState extends Record<string, any>,
@@ -97,17 +97,19 @@ export type ToModelConfig<
  *   }
  * })
  *
- * @deprecated ⚠️ `createEventMap` has been deprecated and will be removed in a future major version. Please use `createModelHook` instead. It uses Template Literal Types to create event map types.
+ * @deprecated `createModelHook` uses Template Literal Types to create event map types
  */
-export 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> => {
-  // Instruct Typescript that all valid guards and callbacks exist
-  return config as EventMap<TEvents, TGuardMap, TCallbackMap>;
-};
+export 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> => {
+    // Instruct Typescript that all valid guards and callbacks exist
+    return config as EventMap<TEvents, TGuardMap, TCallbackMap>;
+  };
 
 // small wrapper to get `keyof T` instead of `string | number | symbol`
 const keys = <T extends object>(input: T) => Object.keys(input) as (keyof T)[];
@@ -131,7 +133,7 @@ const keys = <T extends object>(input: T) => Object.keys(input) as (keyof T)[];
  *     }
  *   }
  * })
- * @deprecated ⚠️ `useEventMap` has been deprecated and will be removed in a future major version. Please use `createModelHook` instead.
+ * @deprecated Use `createModelHook` instead
  */
 export const useEventMap = <
   TEvents extends IEvent,
@@ -207,14 +209,16 @@ type ToEvent<TEvents extends EventCreator> = {
 };
 
 // use this?
-export 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>>
-) => {
-  return {events, eventMap: config as EventMap<ToEvent<TEvents>, TGuardMap, TCallbackMap>};
-};
+export 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>>
+  ) => {
+    return {events, eventMap: config as EventMap<ToEvent<TEvents>, TGuardMap, TCallbackMap>};
+  };
 
 /**
  * Special type that will be a placeholder during development. At build time, this generic will be
@@ -222,8 +226,7 @@ export const createEvents = <TEvents extends EventCreator>(events: TEvents) => <
  * explicit type for your configs to preserve the `Generic` symbol, otherwise Typescript will
  * convert to `any`.
  */
-export type Generic = any
-
+export type Generic = any;
 
 export type ModelExtras<TDefaultConfig, TRequiredConfig, TState, TEvents, TModel> = {
   /** Default config of the model. Useful when composing models to reused config */
@@ -245,12 +248,7 @@ export type ModelExtras<TDefaultConfig, TRequiredConfig, TState, TEvents, TModel
    * */
   getElemProps: <P extends {}>(
     props: P
-  ) => Omit<
-    P,
-    | keyof TDefaultConfig
-    | keyof TRequiredConfig
-    | keyof ToEventConfig<TState, TEvents>
-  >;
+  ) => Omit<P, keyof TDefaultConfig | keyof TRequiredConfig | keyof ToEventConfig<TState, TEvents>>;
   /**
    * A typed function to merge config when composing models together. Guards and Callbacks haven't
    * been resolved yet. `mergeConfig` is a type-attached function that includes guard and callback
@@ -277,9 +275,7 @@ export type ModelExtras<TDefaultConfig, TRequiredConfig, TState, TEvents, TModel
    */
   mergeConfig: (
     source: Partial<TDefaultConfig> & TRequiredConfig,
-    target: Partial<
-      TDefaultConfig & TRequiredConfig & ToEventConfig<TState, TEvents>
-    >
+    target: Partial<TDefaultConfig & TRequiredConfig & ToEventConfig<TState, TEvents>>
   ) => TDefaultConfig & TRequiredConfig & ToEventConfig<TState, TEvents>;
 };
 
@@ -287,16 +283,13 @@ export type ModelExtras<TDefaultConfig, TRequiredConfig, TState, TEvents, TModel
  * Generic type for all models. It makes `defaultConfig` have optional keys and adds `getElemProps`
  * statically to the model function.
  */
-export type ModelFn<
-  TDefaultConfig,
-  TRequiredConfig,
-  TModel
-> = TModel extends { state: infer TState; events: infer TEvents }
+export type ModelFn<TDefaultConfig, TRequiredConfig, TModel> = TModel extends {
+  state: infer TState;
+  events: infer TEvents;
+}
   ? (<TT_Special_Generic>( // special generic used by post processing to handle generic models
-      config?: Partial<TDefaultConfig> &
-        TRequiredConfig &
-        ToEventConfig<TState, TEvents>
-    ) => TModel ) &
+      config?: Partial<TDefaultConfig> & TRequiredConfig & ToEventConfig<TState, TEvents>
+    ) => TModel) &
       ModelExtras<TDefaultConfig, TRequiredConfig, TState, TEvents, TModel>
   : never;
 
@@ -320,15 +313,13 @@ export type ModelFn<
 // contain `state` that are incompatible. More info:
 // https://github.com/damianc/dev-notes/blob/master/typescript/bivariance-hack.md
 export type ToEventConfig<TState, TEvents extends Record<string, any>> = {
-  [K in keyof TEvents as `on${Capitalize<string & K>}`]?: {bivarianceHack(
-    data: Parameters<TEvents[K]>[0],
-    prevState: TState
-  ): void}['bivarianceHack'];
+  [K in keyof TEvents as `on${Capitalize<string & K>}`]?: {
+    bivarianceHack(data: Parameters<TEvents[K]>[0], prevState: TState): void;
+  }['bivarianceHack'];
 } & {
-  [K in keyof TEvents as `should${Capitalize<string & K>}`]?: {bivarianceHack(
-    data: Parameters<TEvents[K]>[0],
-    state: TState
-  ): boolean}['bivarianceHack'];
+  [K in keyof TEvents as `should${Capitalize<string & K>}`]?: {
+    bivarianceHack(data: Parameters<TEvents[K]>[0], state: TState): boolean;
+  }['bivarianceHack'];
 };
 
 function capitalize(string: string) {
@@ -349,12 +340,12 @@ function mergeConfig<TConfig extends Record<string, any>>(
   sourceConfig: Partial<TConfig>,
   newConfig: Partial<TConfig>
 ): TConfig {
-  const result = { ...sourceConfig } as TConfig;
+  const result = {...sourceConfig} as TConfig;
   for (const key in newConfig) {
     if (
-      typeof newConfig[key] === "function" &&
+      typeof newConfig[key] === 'function' &&
       /(on)[A-Z]/.test(key) &&
-      typeof sourceConfig[key] === "function"
+      typeof sourceConfig[key] === 'function'
     ) {
       // merge callbacks and ignore Typescript's errors. We've already tested call signatures
       //  @ts-ignore
@@ -364,11 +355,7 @@ function mergeConfig<TConfig extends Record<string, any>>(
         // @ts-ignore
         newConfig[key](data, state);
       };
-    } else if (
-      newConfig[key] &&
-      /(should)[A-Z]/.test(key) &&
-      sourceConfig[key]
-    ) {
+    } else if (newConfig[key] && /(should)[A-Z]/.test(key) && sourceConfig[key]) {
       // merge guards and ignore Typescript's errors. We've already tested call signatures
       // @ts-ignore
       result[key] = (data: any, state: any) => {
@@ -377,14 +364,16 @@ function mergeConfig<TConfig extends Record<string, any>>(
       };
     } else {
       // @ts-ignore
-      result[key] = newConfig[key]
+      result[key] = newConfig[key];
     }
   }
 
   return result;
 }
 
-export type ExtractModelConfig<T extends (config: any) => any> = T extends (config: infer P) => any ? Required<P> : {}
+export type ExtractModelConfig<T extends (config: any) => any> = T extends (config: infer P) => any
+  ? Required<P>
+  : {};
 
 export type ModelConfig<TDefaultConfig, TRequiredConfig> = {
   /**
@@ -465,7 +454,7 @@ export type ModelConfig<TDefaultConfig, TRequiredConfig> = {
    *   model.state.value // `string`
    * })
    */
-  contextOverride?: React.Context<any>
+  contextOverride?: React.Context<any>;
 };
 
 /**
@@ -494,15 +483,15 @@ export type ModelConfig<TDefaultConfig, TRequiredConfig> = {
 export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig extends {}>(
   options: ModelConfig<TDefaultConfig, TRequiredConfig>
 ) => {
-  const { defaultConfig = {}, requiredConfig = {}, defaultContext, contextOverride } =
-    options;
+  const {defaultConfig = {}, requiredConfig = {}, defaultContext, contextOverride} = options;
 
   // create a bunch of refs so we can define the `wrappedModel` function once.
-  const fnRef: { current: any } = { current: null };
+  const fnRef: {current: any} = {current: null};
 
-  const callbacksRef: { current: string[] } = { current: [] };
-  const guardsRef: { current: string[] } = { current: [] };
-  const Context = contextOverride || React.createContext<any>(defaultContext || {state: {}, events: {}})
+  const callbacksRef: {current: string[]} = {current: []};
+  const guardsRef: {current: string[]} = {current: []};
+  const Context =
+    contextOverride || React.createContext<any>(defaultContext || {state: {}, events: {}});
 
   const getElemProps = (props: object) => {
     // if (eventsRef.current === null) {
@@ -514,9 +503,10 @@ export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig exten
     for (const key in props) {
       if (
         (!defaultConfig.hasOwnProperty(key) &&
-        !requiredConfig.hasOwnProperty(key) &&
-        !callbacksRef.current.includes(key) &&
-        !guardsRef.current.includes(key)) || key === 'id'
+          !requiredConfig.hasOwnProperty(key) &&
+          !callbacksRef.current.includes(key) &&
+          !guardsRef.current.includes(key)) ||
+        key === 'id'
       ) {
         // @ts-ignore  Typescript complains about index signatures and this type is never exposed in definitions, so suppress the error
         elemProps[key] = props[key];
@@ -529,11 +519,11 @@ export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig exten
   // we use `any` here because we don't know what the type is here and it is internal. No use
   // slowing down Typescript to bother type checking
   function wrappedModelHook(config: Record<string, any>) {
-    const stateRef = React.useRef<Record<string, any>>({})
-    const configRef = React.useRef<Record<string, any>>({})
-    const eventsRef = React.useRef<Record<string, any>>({})
+    const stateRef = React.useRef<Record<string, any>>({});
+    const configRef = React.useRef<Record<string, any>>({});
+    const eventsRef = React.useRef<Record<string, any>>({});
 
-    const { state, events, ...rest } = fnRef.current({
+    const {state, events, ...rest} = fnRef.current({
       ...defaultConfig,
       ...config,
     });
@@ -558,10 +548,7 @@ export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig exten
 
             if (
               configRef.current[guardFnName] &&
-              !configRef.current[guardFnName](
-                data,
-                stateRef.current,
-              )
+              !configRef.current[guardFnName](data, stateRef.current)
             ) {
               return;
             }
@@ -572,12 +559,8 @@ export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig exten
 
           const callbackFnName = getCallbackName(key);
           if (!(eventsRef.current[key] as any)._wrapped) {
-
             if (configRef.current[callbackFnName]) {
-              configRef.current[callbackFnName](
-                data,
-                stateRef.current,
-              );
+              configRef.current[callbackFnName](data, stateRef.current);
             }
           }
         };
@@ -588,8 +571,8 @@ export const createModelHook = <TDefaultConfig extends {}, TRequiredConfig exten
       }, {} as Record<string, any>);
     }, []);
 
-  // The model context is private and should never be used
-    return { state, events: wrappedEvents, __UNSTABLE_modelContext: Context, ...rest };
+    // The model context is private and should never be used
+    return {state, events: wrappedEvents, __UNSTABLE_modelContext: Context, ...rest};
   }
 
   wrappedModelHook.getElemProps = getElemProps;

package/dist/commonjs/collection/index.d.ts

@@ -15,6 +15,7 @@ export * from './lib/useGridModel';
 export * from './lib/useListActiveDescendant';
 export * from './lib/useListItemAllowChildStrings';
 export { ListBox, ListBoxProps } from './lib/ListBox';
+export { keyboardEventToCursorEvents } from './lib/keyUtils';
 export { singleSelectionManager, multiSelectionManager, isSelected, } from './lib/useSelectionListModel';
 export { wrappingNavigationManager, navigationManager } from './lib/useCursorListModel';
 //# sourceMappingURL=index.d.ts.map

package/dist/commonjs/collection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../collection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAC1D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,OAAO,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAC,yBAAyB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../collection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAC1D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,OAAO,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,2BAA2B,EAAC,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAC,yBAAyB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC"}

package/dist/commonjs/collection/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.navigationManager = exports.wrappingNavigationManager = exports.isSelected = exports.multiSelectionManager = exports.singleSelectionManager = exports.ListBox = exports.defaultGetId = void 0;
+exports.navigationManager = exports.wrappingNavigationManager = exports.isSelected = exports.multiSelectionManager = exports.singleSelectionManager = exports.keyboardEventToCursorEvents = exports.ListBox = exports.defaultGetId = void 0;
 var useBaseListModel_1 = require("./lib/useBaseListModel");
 Object.defineProperty(exports, "defaultGetId", { enumerable: true, get: function () { return useBaseListModel_1.defaultGetId; } });
 __exportStar(require("./lib/useListItemRegister"), exports);
@@ -30,6 +30,8 @@ __exportStar(require("./lib/useListActiveDescendant"), exports);
 __exportStar(require("./lib/useListItemAllowChildStrings"), exports);
 var ListBox_1 = require("./lib/ListBox");
 Object.defineProperty(exports, "ListBox", { enumerable: true, get: function () { return ListBox_1.ListBox; } });
+var keyUtils_1 = require("./lib/keyUtils");
+Object.defineProperty(exports, "keyboardEventToCursorEvents", { enumerable: true, get: function () { return keyUtils_1.keyboardEventToCursorEvents; } });
 var useSelectionListModel_1 = require("./lib/useSelectionListModel");
 Object.defineProperty(exports, "singleSelectionManager", { enumerable: true, get: function () { return useSelectionListModel_1.singleSelectionManager; } });
 Object.defineProperty(exports, "multiSelectionManager", { enumerable: true, get: function () { return useSelectionListModel_1.multiSelectionManager; } });

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

@@ -10,7 +10,7 @@ export interface Item<T> {
     /**
      * Used by components that allow jumping to an item based on typing
      */
-    textValue?: string;
+    textValue: string;
 }
 export declare const useBaseListModel: (<TT_Special_Generic>(config?: (Partial<{
     /** IDREF of the list. Children ids can be derived from this id */

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

@@ -1 +1 @@
-{"version":3,"file":"useBaseListModel.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useBaseListModel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAA+B,OAAO,EAAC,MAAM,kCAAkC,CAAC;AAEvF,oBAAY,WAAW,GAAG,YAAY,GAAG,UAAU,CAAC;AAEpD,eAAO,MAAM,YAAY,SAAU,GAAG,KAAG,MAExC,CAAC;AAEF,eAAO,MAAM,mBAAmB,SAAU,GAAG,KAAG,MAE/C,CAAC;AAEF,MAAM,WAAW,IAAI,CAAC,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,CAAC,CAAC;IACT;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAmDD,eAAO,MAAM,gBAAgB;IAGzB,kEAAkE;;IAElE;;;;;;OAMG;kBACW,OAAO;IAErB;;;;OAIG;yBACkB,OAAO;IAE5B;;;OAGG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;;IAhDL;;;;OAIG;WACI,OAAO,EAAE;;;cA+GY,OAAO;mBAAa,MAAM;;;;;;;;;;;;;;;;eArB1B,KAAK,OAAO,CAAC,EAAE;;;YAoCf,MAAM;;;;;;;;;;;;;;;;eApCN,KAAK,OAAO,CAAC,EAAE;;;eAuDV,MAAM;;;;;;;;;;;;;;;;eAvDX,KAAK,OAAO,CAAC,EAAE;;;;cAqBf,OAAO;mBAAa,MAAM;;;;;;;;;;;;;;;;eArB1B,KAAK,OAAO,CAAC,EAAE;;;YAoCf,MAAM;;;;;;;;;;;;;;;;eApCN,KAAK,OAAO,CAAC,EAAE;;;eAuDV,MAAM;;;;;;;;;;;;;;;;eAvDX,KAAK,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;eAAf,KAAK,OAAO,CAAC,EAAE;;;QAiBzC;;;WAGG;2BACgB;YAAC,IAAI,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC;QAWrD;;;WAGG;;gBACuB,MAAM;;QAUhC;;;;;;;;WAQG;+BACoB;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;;kBAhIxB,OAAO;;IATrB,kEAAkE;;IAElE;;;;;;OAMG;kBACW,OAAO;IAErB;;;;OAIG;yBACkB,OAAO;IAE5B;;;OAGG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;;IAhDL;;;;OAIG;WACI,OAAO,EAAE;;;;;;;;;;;;;;;;WA0FY,KAAK,OAAO,CAAC,EAAE;;IAiBzC;;;OAGG;uBACgB;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC;IAWrD;;;OAGG;;YACuB,MAAM;;IAUhC;;;;;;;;OAQG;2BACoB;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;;;;eAvDZ,KAAK,OAAO,CAAC,EAAE;;;QAiBzC;;;WAGG;2BACgB;YAAC,IAAI,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC;QAWrD;;;WAGG;;gBACuB,MAAM;;QAUhC;;;;;;;;WAQG;+BACoB;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;;kBAhIxB,OAAO;EAsIvB,CAAC"}
+{"version":3,"file":"useBaseListModel.d.ts","sourceRoot":"","sources":["../../../../collection/lib/useBaseListModel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAA+B,OAAO,EAAC,MAAM,kCAAkC,CAAC;AAEvF,oBAAY,WAAW,GAAG,YAAY,GAAG,UAAU,CAAC;AAEpD,eAAO,MAAM,YAAY,SAAU,GAAG,KAAG,MAExC,CAAC;AAEF,eAAO,MAAM,mBAAmB,SAAU,GAAG,KAAG,MAE/C,CAAC;AAEF,MAAM,WAAW,IAAI,CAAC,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,CAAC,CAAC;IACT;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAmDD,eAAO,MAAM,gBAAgB;IAGzB,kEAAkE;;IAElE;;;;;;OAMG;kBACW,OAAO;IAErB;;;;OAIG;yBACkB,OAAO;IAE5B;;;OAGG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;;IAhDL;;;;OAIG;WACI,OAAO,EAAE;;;cA+GY,OAAO;mBAAa,MAAM;;;;;;;;;;;;;;;;eArB1B,KAAK,OAAO,CAAC,EAAE;;;YAoCf,MAAM;;;;;;;;;;;;;;;;eApCN,KAAK,OAAO,CAAC,EAAE;;;eAuDV,MAAM;;;;;;;;;;;;;;;;eAvDX,KAAK,OAAO,CAAC,EAAE;;;;cAqBf,OAAO;mBAAa,MAAM;;;;;;;;;;;;;;;;eArB1B,KAAK,OAAO,CAAC,EAAE;;;YAoCf,MAAM;;;;;;;;;;;;;;;;eApCN,KAAK,OAAO,CAAC,EAAE;;;eAuDV,MAAM;;;;;;;;;;;;;;;;eAvDX,KAAK,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;eAAf,KAAK,OAAO,CAAC,EAAE;;;QAiBzC;;;WAGG;2BACgB;YAAC,IAAI,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC;QAWrD;;;WAGG;;gBACuB,MAAM;;QAUhC;;;;;;;;WAQG;+BACoB;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;;kBAhIxB,OAAO;;IATrB,kEAAkE;;IAElE;;;;;;OAMG;kBACW,OAAO;IAErB;;;;OAIG;yBACkB,OAAO;IAE5B;;;OAGG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;;IAhDL;;;;OAIG;WACI,OAAO,EAAE;;;;;;;;;;;;;;;;WA0FY,KAAK,OAAO,CAAC,EAAE;;IAiBzC;;;OAGG;uBACgB;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC;IAWrD;;;OAGG;;YACuB,MAAM;;IAUhC;;;;;;;;OAQG;2BACoB;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;;;;eAvDZ,KAAK,OAAO,CAAC,EAAE;;;QAiBzC;;;WAGG;2BACgB;YAAC,IAAI,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC;QAWrD;;;WAGG;;gBACuB,MAAM;;QAUhC;;;;;;;;WAQG;+BACoB;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;;kBAhIxB,OAAO;EAsIvB,CAAC"}

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

@@ -12,7 +12,7 @@ const defaultGetId = (item) => {
 };
 exports.defaultGetId = defaultGetId;
 const defaultGetTextValue = (item) => {
-    return typeof item === 'string' ? item : item.text || '';
+    return typeof item === 'string' ? item : item.text || item.id || '';
 };
 exports.defaultGetTextValue = defaultGetTextValue;
 // interface Collection<T> {
@@ -99,7 +99,7 @@ exports.useBaseListModel = common_1.createModelHook({
     const getIdRef = react_1.default.useRef(exports.defaultGetId);
     const getTextValueRef = react_1.default.useRef(exports.defaultGetTextValue);
     const getId = config.getId || exports.defaultGetId;
-    const getTextValue = config.getTextValue || exports.defaultGetTextValue;
+    const getTextValue = config.getTextValue || config.getId || exports.defaultGetTextValue;
     getIdRef.current = getId;
     getTextValueRef.current = getTextValue;
     const [orientation] = react_1.default.useState(config.orientation || 'vertical');

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

@@ -21,7 +21,7 @@ const useListModel_1 = require("./useListModel");
  * ```
  */
 exports.useListItemRegister = common_1.createElemPropsHook(useListModel_1.useListModel)(({ state, events }, ref, elemProps = {}) => {
-    var _a, _b, _c;
+    var _a, _b;
     const [localId, setLocalId] = react_1.default.useState(elemProps['data-id'] || ((_a = elemProps.item) === null || _a === void 0 ? void 0 : _a.id) || '');
     const { localRef, elementRef } = common_1.useLocalRef(common_1.useForkRef(ref, (_b = elemProps.virtual) === null || _b === void 0 ? void 0 : _b.measureRef));
     // if the list is virtual, force the correct styling. Without this, weird things happen...
@@ -71,7 +71,7 @@ exports.useListItemRegister = common_1.createElemPropsHook(useListModel_1.useLis
         disabled: elemProps.disabled || state.nonInteractiveIds.includes(localId) ? true : undefined,
         item: null,
         virtual: null,
-        'aria-setsize': (_c = elemProps.virtual) === null || _c === void 0 ? void 0 : _c.size,
+        'aria-setsize': elemProps.virtual ? state.UNSTABLE_virtual.totalSize : undefined,
         'aria-posinset': elemProps.virtual ? elemProps.item.index + 1 : undefined,
         style,
         id: common_1.slugify(`${state.id}-${localId}`),

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

@@ -31,7 +31,7 @@ function useListRenderItems(model, children) {
                         // about capital letters in attributes. React thinks this will be applied to the DOM
                         // element even though we remove it later...
                         virtual,
-                        key: item.id,
+                        key: item.id || item.index,
                         item,
                     });
                 }
@@ -41,7 +41,7 @@ function useListRenderItems(model, children) {
                 const child = children(item.value, item.index);
                 if (react_1.default.isValidElement(child)) {
                     return react_1.default.cloneElement(child, {
-                        key: item.id,
+                        key: item.id || item.index,
                         item: item.value,
                     });
                 }

package/dist/commonjs/combobox/index.d.ts

@@ -2,8 +2,5 @@ export { Combobox } from './lib/Combobox';
 export { useComboboxCard } from './lib/ComboboxCard';
 export { useComboboxMenuItem } from './lib/ComboboxMenuItem';
 export { useComboboxMenuList } from './lib/ComboboxMenuList';
-export { useComboboxInput } from './lib/ComboboxInput';
-export { useComboboxLoader } from './lib/useComboboxLoader';
-export { useComboboxModel } from './lib/useComboboxModel';
-export { useComboboxInputOpenWithArrowKeys as useComboboxOpenWithArrowKeys } from './lib/useComboboxInputOpenWithArrowKeys';
+export { useComboboxLoader, useComboboxModel, useComboboxInputOpenWithArrowKeys, useComboboxKeyboardTypeAhead, useSetPopupWidth, useComboboxMoveCursorToSelected, useComboboxInput, useComboboxListKeyboardHandler, useComboboxResetCursorToSelected, } from './lib/hooks';
 //# sourceMappingURL=index.d.ts.map

package/dist/commonjs/combobox/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../combobox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,iCAAiC,IAAI,4BAA4B,EAAC,MAAM,yCAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../combobox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,iCAAiC,EACjC,4BAA4B,EAC5B,gBAAgB,EAChB,+BAA+B,EAC/B,gBAAgB,EAChB,8BAA8B,EAC9B,gCAAgC,GACjC,MAAM,aAAa,CAAC"}

package/dist/commonjs/combobox/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useComboboxOpenWithArrowKeys = exports.useComboboxModel = exports.useComboboxLoader = exports.useComboboxInput = exports.useComboboxMenuList = exports.useComboboxMenuItem = exports.useComboboxCard = exports.Combobox = void 0;
+exports.useComboboxResetCursorToSelected = exports.useComboboxListKeyboardHandler = exports.useComboboxInput = exports.useComboboxMoveCursorToSelected = exports.useSetPopupWidth = exports.useComboboxKeyboardTypeAhead = exports.useComboboxInputOpenWithArrowKeys = exports.useComboboxModel = exports.useComboboxLoader = exports.useComboboxMenuList = exports.useComboboxMenuItem = exports.useComboboxCard = exports.Combobox = void 0;
 var Combobox_1 = require("./lib/Combobox");
 Object.defineProperty(exports, "Combobox", { enumerable: true, get: function () { return Combobox_1.Combobox; } });
 var ComboboxCard_1 = require("./lib/ComboboxCard");
@@ -9,11 +9,13 @@ var ComboboxMenuItem_1 = require("./lib/ComboboxMenuItem");
 Object.defineProperty(exports, "useComboboxMenuItem", { enumerable: true, get: function () { return ComboboxMenuItem_1.useComboboxMenuItem; } });
 var ComboboxMenuList_1 = require("./lib/ComboboxMenuList");
 Object.defineProperty(exports, "useComboboxMenuList", { enumerable: true, get: function () { return ComboboxMenuList_1.useComboboxMenuList; } });
-var ComboboxInput_1 = require("./lib/ComboboxInput");
-Object.defineProperty(exports, "useComboboxInput", { enumerable: true, get: function () { return ComboboxInput_1.useComboboxInput; } });
-var useComboboxLoader_1 = require("./lib/useComboboxLoader");
-Object.defineProperty(exports, "useComboboxLoader", { enumerable: true, get: function () { return useComboboxLoader_1.useComboboxLoader; } });
-var useComboboxModel_1 = require("./lib/useComboboxModel");
-Object.defineProperty(exports, "useComboboxModel", { enumerable: true, get: function () { return useComboboxModel_1.useComboboxModel; } });
-var useComboboxInputOpenWithArrowKeys_1 = require("./lib/useComboboxInputOpenWithArrowKeys");
-Object.defineProperty(exports, "useComboboxOpenWithArrowKeys", { enumerable: true, get: function () { return useComboboxInputOpenWithArrowKeys_1.useComboboxInputOpenWithArrowKeys; } });
+var hooks_1 = require("./lib/hooks");
+Object.defineProperty(exports, "useComboboxLoader", { enumerable: true, get: function () { return hooks_1.useComboboxLoader; } });
+Object.defineProperty(exports, "useComboboxModel", { enumerable: true, get: function () { return hooks_1.useComboboxModel; } });
+Object.defineProperty(exports, "useComboboxInputOpenWithArrowKeys", { enumerable: true, get: function () { return hooks_1.useComboboxInputOpenWithArrowKeys; } });
+Object.defineProperty(exports, "useComboboxKeyboardTypeAhead", { enumerable: true, get: function () { return hooks_1.useComboboxKeyboardTypeAhead; } });
+Object.defineProperty(exports, "useSetPopupWidth", { enumerable: true, get: function () { return hooks_1.useSetPopupWidth; } });
+Object.defineProperty(exports, "useComboboxMoveCursorToSelected", { enumerable: true, get: function () { return hooks_1.useComboboxMoveCursorToSelected; } });
+Object.defineProperty(exports, "useComboboxInput", { enumerable: true, get: function () { return hooks_1.useComboboxInput; } });
+Object.defineProperty(exports, "useComboboxListKeyboardHandler", { enumerable: true, get: function () { return hooks_1.useComboboxListKeyboardHandler; } });
+Object.defineProperty(exports, "useComboboxResetCursorToSelected", { enumerable: true, get: function () { return hooks_1.useComboboxResetCursorToSelected; } });

package/dist/commonjs/combobox/lib/Combobox.d.ts

@@ -6,8 +6,8 @@ export interface ComboboxProps {
     children: React.ReactNode;
 }
 export declare const Combobox: import("@workday/canvas-kit-react/common").ComponentM<ComboboxProps & Partial<{
-    mode: "multiple" | "single";
     shouldVirtualize: boolean;
+    mode: "multiple" | "single";
     returnFocusRef: React.RefObject<any> | undefined;
     initialFocusRef: React.RefObject<any> | undefined;
     id: string;
@@ -1766,7 +1766,7 @@ export declare const Combobox: import("@workday/canvas-kit-react/common").Compon
         navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
         getId: (item: any) => string;
     }> & {
-        Popper: import("@workday/canvas-kit-react/common").ElementComponentM<"div", import("../../menu/lib/MenuPopper").MenuPopperProps, {
+        Popper: import("@workday/canvas-kit-react/common").ElementComponentM<"div", import("../..").PopperProps & React.RefAttributes<HTMLDivElement>, {
             state: {
                 stackRef: React.RefObject<HTMLDivElement>;
                 targetRef: React.RefObject<HTMLButtonElement>;
@@ -1991,7 +1991,13 @@ export declare const Combobox: import("@workday/canvas-kit-react/common").Compon
             selection: import("../../collection/lib/useSelectionListModel").SelectionManager;
             navigation: import("../../collection/lib/useCursorListModel").NavigationManager;
             getId: (item: any) => string;
-        }>;
+        }> & {
+            Icon: import("@emotion/styled").StyledComponent<import("../..").SystemIconProps & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "as" | keyof import("../..").SystemIconProps> & {
+                ref?: React.Ref<HTMLSpanElement> | undefined;
+            } & {
+                theme?: import("@emotion/react").Theme | undefined;
+            }, {}, {}>;
+        };
         Card: import("@workday/canvas-kit-react/common").ElementComponentM<"div", import("./ComboboxCard").ComboboxCardProps, {
             state: {
                 stackRef: React.RefObject<HTMLDivElement>;

package/dist/commonjs/combobox/lib/Combobox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Combobox.d.ts","sourceRoot":"","sources":["../../../../combobox/lib/Combobox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIjB;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKL,CAAC"}
+{"version":3,"file":"Combobox.d.ts","sourceRoot":"","sources":["../../../../combobox/lib/Combobox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIjB;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKL,CAAC"}

package/dist/commonjs/combobox/lib/Combobox.js

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Combobox = void 0;
 const react_1 = __importDefault(require("react"));
 const common_1 = require("@workday/canvas-kit-react/common");
-const useComboboxModel_1 = require("./useComboboxModel");
+const hooks_1 = require("./hooks");
 const ComboboxInput_1 = require("./ComboboxInput");
 const ComboboxMenu_1 = require("./ComboboxMenu");
 exports.Combobox = common_1.createContainer()({
     displayName: 'Combobox',
-    modelHook: useComboboxModel_1.useComboboxModel,
+    modelHook: hooks_1.useComboboxModel,
     subComponents: {
         /**
          * The input of the `Combobox`. This element will have `role="combobox"` applied, along with

package/dist/commonjs/combobox/lib/ComboboxCard.js

@@ -7,18 +7,18 @@ exports.ComboboxCard = exports.useComboboxCard = void 0;
 const react_1 = __importDefault(require("react"));
 const common_1 = require("@workday/canvas-kit-react/common");
 const menu_1 = require("@workday/canvas-kit-react/menu");
-const useComboboxModel_1 = require("./useComboboxModel");
+const hooks_1 = require("./hooks");
 /**
  * This hook sets the `minWidth` style attribute to match the width of the
  * {@link ComboboxInput Combobox.Input} component.
  */
-exports.useComboboxCard = common_1.createElemPropsHook(useComboboxModel_1.useComboboxModel)(model => {
+exports.useComboboxCard = common_1.createElemPropsHook(hooks_1.useComboboxModel)(model => {
     return {
         minWidth: model.state.width,
     };
 });
 exports.ComboboxCard = common_1.createSubcomponent('div')({
-    modelHook: useComboboxModel_1.useComboboxModel,
+    modelHook: hooks_1.useComboboxModel,
     elemPropsHook: exports.useComboboxCard,
 })(({ children, ...elemProps }, Element) => {
     return (react_1.default.createElement(menu_1.Menu.Card, Object.assign({ as: Element }, elemProps), children));