@aws-amplify/ui 5.5.5 → 5.5.6

package/dist/types/theme/tokens/components/autocomplete.d.ts

@@ -1,13 +1,13 @@
 import { DesignTokenProperties, OutputVariantKey } from '../types/designToken';
 export declare type AutocompleteTokens<OutputType extends OutputVariantKey> = {
     menu?: DesignTokenProperties<'backgroundColor' | 'borderColor' | 'borderRadius' | 'borderStyle' | 'borderWidth' | 'marginBlockStart' | 'width', OutputType> & {
-        options: DesignTokenProperties<'display' | 'flexDirection' | 'maxHeight', OutputType>;
-        option: DesignTokenProperties<'backgroundColor' | 'color' | 'cursor' | 'transitionDuration' | 'transitionProperty' | 'transitionTimingFunction', OutputType> & {
-            _active: DesignTokenProperties<'backgroundColor' | 'color', OutputType>;
+        options?: DesignTokenProperties<'display' | 'flexDirection' | 'maxHeight', OutputType>;
+        option?: DesignTokenProperties<'backgroundColor' | 'color' | 'cursor' | 'transitionDuration' | 'transitionProperty' | 'transitionTimingFunction', OutputType> & {
+            _active?: DesignTokenProperties<'backgroundColor' | 'color', OutputType>;
         };
-        _empty: DesignTokenProperties<'display', OutputType>;
-        _loading: DesignTokenProperties<'alignItems' | 'display' | 'gap', OutputType>;
-        spaceShared: DesignTokenProperties<'paddingBlock' | 'paddingInline', OutputType>;
+        _empty?: DesignTokenProperties<'display', OutputType>;
+        _loading?: DesignTokenProperties<'alignItems' | 'display' | 'gap', OutputType>;
+        spaceShared?: DesignTokenProperties<'paddingBlock' | 'paddingInline', OutputType>;
     };
 };
 export declare const autocomplete: Required<AutocompleteTokens<'default'>>;

package/dist/types/theme/tokens/components/checkbox.d.ts

@@ -2,11 +2,11 @@ import { DesignTokenProperties, OutputVariantKey } from '../types/designToken';
 declare type ButtonFocusToken<Output> = DesignTokenProperties<'outlineColor' | 'outlineStyle' | 'outlineWidth' | 'outlineOffset' | 'borderColor' | 'boxShadow', Output>;
 declare type BeforeToken<Output> = DesignTokenProperties<'width' | 'height' | 'borderWidth' | 'borderRadius' | 'borderStyle' | 'borderColor', Output>;
 declare type ButtonToken<Output> = DesignTokenProperties<'position' | 'alignItems' | 'justifyContent' | 'color', Output> & {
-    before: BeforeToken<Output>;
-    _focus: ButtonFocusToken<Output>;
-    _disabled: DesignTokenProperties<'borderColor', Output>;
-    _error: DesignTokenProperties<'borderColor', Output> & {
-        _focus: DesignTokenProperties<'borderColor' | 'boxShadow', Output>;
+    before?: BeforeToken<Output>;
+    _focus?: ButtonFocusToken<Output>;
+    _disabled?: DesignTokenProperties<'borderColor', Output>;
+    _error?: DesignTokenProperties<'borderColor', Output> & {
+        _focus?: DesignTokenProperties<'borderColor' | 'boxShadow', Output>;
     };
 };
 declare type IconCheckedStateToken<Output> = DesignTokenProperties<'opacity' | 'transform'> & {

package/dist/types/theme/types.d.ts

@@ -1,4 +1,4 @@
-import { PartialDeep } from 'type-fest';
+import { PartialDeep } from '../types';
 import { DefaultTokens, Tokens, WebTokens } from './tokens';
 import { Breakpoints } from './breakpoints';
 export * from './tokens/types/designToken';

package/dist/types/types/util.d.ts

@@ -1 +1,96 @@
 export declare type NoInfer<T> = [T][T extends any ? 0 : never];
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+declare type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+Matches any primitive, `Date`, or `RegExp` value.
+*/
+declare type BuiltIns = Primitive | Date | RegExp;
+/**
+@see PartialDeep
+*/
+export interface PartialDeepOptions {
+    /**
+      Whether to affect the individual elements of arrays and tuples.
+  
+      @default true
+      */
+    readonly recurseIntoArrays?: boolean;
+}
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+const settings: Settings = {
+    textEditor: {
+        fontSize: 14;
+        fontColor: '#000000';
+        fontWeight: 400;
+    }
+    autocomplete: false;
+    autosave: true;
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+    return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this also affects array and tuple types:
+
+```
+
+interface Settings {
+    languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings> = {
+    languages: [undefined]
+};
+```
+
+If this is undesirable, you can pass `{recurseIntoArrays: false}` as the second type argument.
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export declare type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends ReadonlyArray<infer ItemType> ? Options['recurseIntoArrays'] extends false ? T : ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<PartialDeep<ItemType | undefined, Options>> : Array<PartialDeep<ItemType | undefined, Options>> : PartialObjectDeep<T, Options> : PartialObjectDeep<T, Options> : unknown;
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {
+}
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialSetDeep<T, Options extends PartialDeepOptions> extends Set<PartialDeep<T, Options>> {
+}
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {
+}
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+interface PartialReadonlySetDeep<T, Options extends PartialDeepOptions> extends ReadonlySet<PartialDeep<T, Options>> {
+}
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+declare type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
+    [KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>;
+};
+export {};

package/dist/types/utils/index.d.ts

@@ -1,17 +1,3 @@
-/**
- * We re-export any lodash imports to avoid appending .js extension across codebase
- * The ultimate goal is have replacement implementation to remove the entire dependency
- */
-export { default as isEqual } from 'lodash/isEqual.js';
-export { default as isEmpty } from 'lodash/isEmpty.js';
-export { default as debounce } from 'lodash/debounce.js';
-export { default as isNil } from 'lodash/isNil.js';
-export { default as includes } from 'lodash/includes.js';
-export { default as get } from 'lodash/get.js';
-export { default as pickBy } from 'lodash/pickBy.js';
-export { default as has } from 'lodash/has.js';
-export { default as kebabCase } from 'lodash/kebabCase.js';
-export { default as merge } from 'lodash/merge.js';
 /**
  * Some libraries may not follow Node ES module spec and could be loaded as CommonJS modules,
  * To ensure the interoperability between ESM and CJS, modules from those libraries have to be loaded via namespace import
@@ -35,6 +21,20 @@ export declare function isObject(value: unknown): value is object;
  * @returns {boolean} Returns `true` if `value` is a string, `false` otherwise
  */
 export declare function isString(value: unknown): value is string;
+/**
+ * Checks if `value` is a Map
+ *
+ * @param {unknown} value The value to check
+ * @returns {boolean} Returns `true` if `value` is a Map, `false` otherwise
+ */
+export declare function isMap(value: unknown): value is Map<unknown, unknown>;
+/**
+ * Checks if `value` is a Set
+ *
+ * @param {unknown} value The value to check
+ * @returns {boolean} Returns `true` if `value` is a Set, `false` otherwise
+ */
+export declare function isSet<T>(value: unknown): value is Set<T>;
 /**
  * Checks if `value` is undefined
  *
@@ -43,8 +43,52 @@ export declare function isString(value: unknown): value is string;
  */
 export declare function isUndefined(value: unknown): value is undefined;
 /**
+ * Checks if `value` is nullish
  *
- * @param value capitalizes `value` and its type.
- * @returns Capitalized `value`
+ * @param {unknown} value The value to check
+ * @returns {boolean} Returns `true` if `value` is nullish, `false` otherwise
+ */
+export declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Checks if `value` is empty
+ *
+ * @param {unknown} value The value to check
+ * @returns {boolean} Returns `true` if `value` is empty, `false` otherwise
+ */
+export declare function isEmpty<T>(value: T): boolean;
+/**
+ * Checks if all members of the `values` param are empty arrays
+ *
+ * @param {unknown} value The values to check
+ * @returns {boolean} Returns `true` if all members of `values` are empty, `false` otherwise
+ */
+export declare function areEmptyArrays<T>(...values: T[]): boolean;
+/**
+ * Checks if all members of the `values` param are empty objects
+ *
+ * @param {unknown} values The values to check
+ * @returns {boolean} Returns `true` if all members of the `values` param are empty, `false` otherwise
+ */
+export declare function areEmptyObjects<T>(...values: T[]): boolean;
+/**
+ * Capitalizes `value` and its return type
+ *
+ * @param {string} value string to capitalize
+ * @returns {string} capitalized string
  */
 export declare function capitalize<T extends string>(value: T): Capitalize<T>;
+/**
+ * Checks if `key` is a direct property of `value`
+ *
+ * @param {unknown} value `object` potentially containing property
+ * @param {string} key property key
+ * @returns whether `key` param is a property of the `obj` param
+ */
+export declare function has(value: unknown, key: string): boolean;
+/**
+ * Checks if `value` is a function
+ *
+ * @param {unknown} value param to check
+ * @returns {boolean} whether `value` is a function
+ */
+export declare function isFunction(value: unknown): value is Function;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/ui",
-  "version": "5.5.5",
+  "version": "5.5.6",
   "main": "dist/index.js",
   "module": "dist/esm/index.mjs",
   "exports": {
@@ -76,8 +76,7 @@
     "rollup-plugin-terser": "^7.0.2",
     "sass": "^1.35.2",
     "ts-jest": "^27.0.3",
-    "ts-node": "^10.2.1",
-    "type-fest": "^2.3.4"
+    "ts-node": "^10.2.1"
   },
   "sideEffects": [
     "dist/**/*.css"