@salutejs/plasma-new-hope 0.152.0-canary.1445.11027864145.0 → 0.152.0-canary.1449.11029161599.0

package/types/examples/plasma_web/components/Mask/Mask.d.ts

@@ -16,6 +16,115 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
         inner: import("@linaria/core").LinariaClassName;
         outer: import("@linaria/core").LinariaClassName;
     };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    disabled: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    readOnly: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+}> & {
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement> & import("../../../../components/Mask/Mask.types").MaskProps, "ref"> | Omit<import("../../../../engines/types").PropsType<{
+    view: {
+        default: import("@linaria/core").LinariaClassName;
+        positive: import("@linaria/core").LinariaClassName;
+        warning: import("@linaria/core").LinariaClassName;
+        negative: import("@linaria/core").LinariaClassName;
+    };
+    size: {
+        l: import("@linaria/core").LinariaClassName;
+        m: import("@linaria/core").LinariaClassName;
+        s: import("@linaria/core").LinariaClassName;
+        xs: import("@linaria/core").LinariaClassName;
+    };
+    labelPlacement: {
+        inner: import("@linaria/core").LinariaClassName;
+        outer: import("@linaria/core").LinariaClassName;
+    };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    disabled: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    readOnly: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+}> & {
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement> & import("../../../../components/Mask/Mask.types").MaskProps, "ref"> | Omit<import("../../../../engines/types").PropsType<{
+    view: {
+        default: import("@linaria/core").LinariaClassName;
+        positive: import("@linaria/core").LinariaClassName;
+        warning: import("@linaria/core").LinariaClassName;
+        negative: import("@linaria/core").LinariaClassName;
+    };
+    size: {
+        l: import("@linaria/core").LinariaClassName;
+        m: import("@linaria/core").LinariaClassName;
+        s: import("@linaria/core").LinariaClassName;
+        xs: import("@linaria/core").LinariaClassName;
+    };
+    labelPlacement: {
+        inner: import("@linaria/core").LinariaClassName;
+        outer: import("@linaria/core").LinariaClassName;
+    };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -41,6 +150,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
 } & {
     required: true;
     optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -63,6 +175,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
         inner: import("@linaria/core").LinariaClassName;
         outer: import("@linaria/core").LinariaClassName;
     };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -88,6 +203,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
 } & {
     required: true;
     optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;
@@ -110,6 +228,115 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
         inner: import("@linaria/core").LinariaClassName;
         outer: import("@linaria/core").LinariaClassName;
     };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    disabled: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    readOnly: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+}> & {
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement> & import("../../../../components/Mask/Mask.types").MaskProps, "ref"> | Omit<import("../../../../engines/types").PropsType<{
+    view: {
+        default: import("@linaria/core").LinariaClassName;
+        positive: import("@linaria/core").LinariaClassName;
+        warning: import("@linaria/core").LinariaClassName;
+        negative: import("@linaria/core").LinariaClassName;
+    };
+    size: {
+        l: import("@linaria/core").LinariaClassName;
+        m: import("@linaria/core").LinariaClassName;
+        s: import("@linaria/core").LinariaClassName;
+        xs: import("@linaria/core").LinariaClassName;
+    };
+    labelPlacement: {
+        inner: import("@linaria/core").LinariaClassName;
+        outer: import("@linaria/core").LinariaClassName;
+    };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    disabled: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+    readOnly: {
+        true: import("@linaria/core").LinariaClassName;
+    };
+}> & {
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement> & import("../../../../components/Mask/Mask.types").MaskProps, "ref"> | Omit<import("../../../../engines/types").PropsType<{
+    view: {
+        default: import("@linaria/core").LinariaClassName;
+        positive: import("@linaria/core").LinariaClassName;
+        warning: import("@linaria/core").LinariaClassName;
+        negative: import("@linaria/core").LinariaClassName;
+    };
+    size: {
+        l: import("@linaria/core").LinariaClassName;
+        m: import("@linaria/core").LinariaClassName;
+        s: import("@linaria/core").LinariaClassName;
+        xs: import("@linaria/core").LinariaClassName;
+    };
+    labelPlacement: {
+        inner: import("@linaria/core").LinariaClassName;
+        outer: import("@linaria/core").LinariaClassName;
+    };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -135,6 +362,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
 } & {
     optional?: true | undefined;
     required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -157,6 +387,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
         inner: import("@linaria/core").LinariaClassName;
         outer: import("@linaria/core").LinariaClassName;
     };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -182,6 +415,9 @@ export declare const Mask: import("react").ForwardRefExoticComponent<(Omit<impor
 } & {
     optional?: true | undefined;
     required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;

package/types/examples/plasma_web/components/Mask/Mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mask.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/Mask/Mask.ts"],"names":[],"mappings":";AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2QAAyB,CAAC"}
+{"version":3,"file":"Mask.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/Mask/Mask.ts"],"names":[],"mappings":";AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2QAAyB,CAAC"}

package/types/examples/plasma_web/components/TextField/TextField.config.d.ts

@@ -21,6 +21,9 @@ export declare const config: {
             inner: import("@linaria/core").LinariaClassName;
             outer: import("@linaria/core").LinariaClassName;
         };
+        clear: {
+            true: import("@linaria/core").LinariaClassName;
+        };
         disabled: {
             true: import("@linaria/core").LinariaClassName;
         };

package/types/examples/plasma_web/components/TextField/TextField.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextField.config.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.config.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuZlB,CAAC"}
+{"version":3,"file":"TextField.config.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.config.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8alB,CAAC"}

package/types/examples/plasma_web/components/TextField/TextField.d.ts

@@ -16,6 +16,9 @@ export declare const TextField: import("react").FunctionComponent<import("../../
         inner: import("@linaria/core").LinariaClassName;
         outer: import("@linaria/core").LinariaClassName;
     };
+    clear: {
+        true: import("@linaria/core").LinariaClassName;
+    };
     disabled: {
         true: import("@linaria/core").LinariaClassName;
     };
@@ -41,6 +44,63 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     required: true;
     optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    required: true;
+    optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -65,6 +125,9 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     required: true;
     optional?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;
@@ -89,6 +152,9 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     optional?: true | undefined;
     required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
 } & {
     chips?: undefined;
     onChangeChips?: undefined;
@@ -113,6 +179,63 @@ export declare const TextField: import("react").FunctionComponent<import("../../
 } & {
     optional?: true | undefined;
     required?: false | undefined;
+} & {
+    clear?: boolean | undefined;
+    hasDivider?: boolean | undefined;
+} & {
+    enumerationType: "chip";
+    onSearch?: undefined;
+    chips?: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[] | undefined;
+    onChangeChips?: ((value: import("../../../../components/TextField/TextField.types").TextFieldPrimitiveValue[]) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
+} & {
+    chips?: undefined;
+    onChangeChips?: undefined;
+    enumerationType?: "plain" | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & Omit<import("../../../../types").InputHTMLAttributes<HTMLInputElement>, "required" | "size"> & import("react").RefAttributes<HTMLInputElement>) | ({
+    size?: string | undefined;
+    view?: string | undefined;
+    readOnly?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & {
+    label?: string | undefined;
+    labelPlacement?: "inner" | "outer" | undefined;
+    leftHelper?: string | undefined;
+    contentLeft?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    contentRight?: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
+    textBefore?: string | undefined;
+    textAfter?: string | undefined;
+    onSearch?: ((value: string, event?: import("react").KeyboardEvent<HTMLInputElement> | undefined) => void) | undefined;
+} & {
+    requiredPlacement?: "left" | "right" | undefined;
+} & {
+    optional?: true | undefined;
+    required?: false | undefined;
+} & {
+    clear?: false | undefined;
+    hasDivider?: undefined;
 } & {
     enumerationType: "chip";
     onSearch?: undefined;

package/types/examples/plasma_web/components/TextField/TextField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextField.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAA0B,CAAC"}
+{"version":3,"file":"TextField.d.ts","sourceRoot":"","sources":["../../../../../src/examples/plasma_web/components/TextField/TextField.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAA0B,CAAC"}

package/types/index.d.ts

@@ -7,7 +7,6 @@ export * from './components/IconButton';
 export * from './components/ButtonGroup';
 export * from './components/Breadcrumbs';
 export * from './components/Chip';
-export * from './components/ChipGroup';
 export * from './components/Cell';
 export * from './components/Link';
 export * from './components/Spinner';

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC"}

package/cjs/components/ChipGroup/ChipGroup.css

@@ -1,7 +0,0 @@
-.ChipGroup_styles_1l3nd6v_bzgm0e4__3638f601{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}.ChipGroup_styles_1l3nd6v_bzgm0e4__3638f601.ChipGroup_styles_1l3nd6v_chipGroupWrap__3638f601{-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}
-
-.base_122089q_brey5rj__0d881afa.base_122089q_chipGroupOverrideStyles__0d881afa .base_122089q_chipItem__0d881afa{--plasma-chip-background:var(--plasma-chip-group-items-background);--plasma-chip-color:var(--plasma-chip-group-items-color);--plasma-chip-background-hover:var(--plasma-chip-group-items-background-hover);--plasma-chip-color-hover:var(--plasma-chip-group-items-color-hover);--plasma-chip-scale-hover:var(--plasma-chip-group-items-scale-hover);--plasma-chip-background-active:var(--plasma-chip-group-items-background-active);--plasma-chip-color-active:var(--plasma-chip-group-items-color-active);--plasma-chip-scale-active:var(--plasma-chip-group-items-scale-active);--plasma-chip-focus-color:var(--plasma-chip-group-items-focus-color);--plasma-chip-outline-size:var(--plasma-chip-group-items-outline-size);--plasma-chip-close-icon-color:var(--plasma-chip-group-items-close-icon-color);--plasma-chip-close-icon-color-hover:var(--plasma-chip-group-items-close-icon-color-hover);--plasma-chip-close-icon-color-active:var(--plasma-chip-group-items-close-icon-color-active);}
-
-.base_eu60ye_b8we6fx__49af8456.base_eu60ye_chipGroupOverrideStyles__49af8456 .base_eu60ye_chipItem__49af8456{--plasma-chip-height:var(--plasma-chip-group-item-height);--plasma-chip-width:var(--plasma-chip-group-item-width);--plasma-chip-border-radius:var(--plasma-chip-group-items-border-radius);--plasma-chip-padding-top:var(--plasma-chip-group-item-padding-top);--plasma-chip-padding-right:var(--plasma-chip-group-item-padding-right);--plasma-chip-padding-bottom:var(--plasma-chip-group-item-padding-bottom);--plasma-chip-padding-left:var(--plasma-chip-group-item-padding-left);--plasma-chip-close-icon-size:var(--plasma-chip-group-item-close-icon-size);--plasma-chip-font-family:var(--plasma-chip-group-item-font-family);--plasma-chip-font-size:var(--plasma-chip-group-item-font-size);--plasma-chip-font-style:var(--plasma-chip-group-item-font-style);--plasma-chip-font-weight:var(--plasma-chip-group-item-font-weight);--plasma-chip-letter-spacing:var(--plasma-chip-group-item-letter-spacing);--plasma-chip-lineheight:var(--plasma-chip-group-item-line-height);--plasma-chip-left-content-margin-left:var(--plasma-chip-group-item-left-content-margin-left);--plasma-chip-left-content-margin-right:var(--plasma-chip-group-item-left-content-margin-right);--plasma-chip-right-content-margin-left:var(--plasma-chip-group-item-right-content-margin-left);--plasma-chip-right-content-margin-right:var(--plasma-chip-group-item-right-content-margin-right);--plasma-chip-clear-content-margin-left:var(--plasma-chip-group-item-clear-content-margin-left);--plasma-chip-clear-content-margin-right:var(--plasma-chip-group-item-clear-content-margin-right);}
-
-.base_vhoe9f_b5zwimg__1f583b8c{gap:var(--plasma-chip-group-items-gap);}

package/cjs/components/ChipGroup/ChipGroup.js

@@ -1,63 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
-var React = require('react');
-var index = require('../../utils/index.js');
-var ChipGroup_styles = require('./ChipGroup.styles.js');
-var base = require('./variations/_view/base.js');
-var base$1 = require('./variations/_size/base.js');
-var base$2 = require('./variations/_gap/base.js');
-var ChipGroup_tokens = require('./ChipGroup.tokens.js');
-
-var _excluded = ["children", "view", "size", "className", "isWrapped", "gap", "isCommonChipStyles"];
-var chipGroupRoot = function chipGroupRoot(Root) {
-  return /*#__PURE__*/React.forwardRef(function (props, ref) {
-    var children = props.children,
-      view = props.view,
-      size = props.size,
-      className = props.className,
-      isWrapped = props.isWrapped,
-      _props$gap = props.gap,
-      gap = _props$gap === void 0 ? 'dense' : _props$gap,
-      _props$isCommonChipSt = props.isCommonChipStyles,
-      isCommonChipStyles = _props$isCommonChipSt === void 0 ? true : _props$isCommonChipSt,
-      rest = _rollupPluginBabelHelpers.objectWithoutProperties(props, _excluded);
-    var overrideStylesClass = isCommonChipStyles ? ChipGroup_tokens.classes.chipGroupOverrideStyles : undefined;
-    var wrappedClass = isWrapped ? ChipGroup_tokens.classes.wrap : undefined;
-    return /*#__PURE__*/React.createElement(Root, _rollupPluginBabelHelpers.extends({
-      ref: ref,
-      view: view,
-      size: size,
-      gap: gap,
-      className: index.cx(overrideStylesClass, wrappedClass, className)
-    }, rest), children);
-  });
-};
-var chipGroupConfig = {
-  name: 'ChipGroup',
-  tag: 'div',
-  layout: chipGroupRoot,
-  base: ChipGroup_styles.base,
-  variations: {
-    view: {
-      css: base.base
-    },
-    size: {
-      css: base$1.base
-    },
-    gap: {
-      css: base$2.base
-    }
-  },
-  defaults: {
-    view: 'primary',
-    size: 'm',
-    gap: 'dense'
-  }
-};
-
-exports.chipGroupConfig = chipGroupConfig;
-exports.chipGroupRoot = chipGroupRoot;
-//# sourceMappingURL=ChipGroup.js.map

package/cjs/components/ChipGroup/ChipGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChipGroup.js","sources":["../../../src/components/ChipGroup/ChipGroup.tsx"],"sourcesContent":["import React, { forwardRef } from 'react';\n\nimport type { RootProps } from '../../engines';\nimport { cx } from '../../utils';\n\nimport { base } from './ChipGroup.styles';\nimport { base as viewCSS } from './variations/_view/base';\nimport { base as sizeCSS } from './variations/_size/base';\nimport { base as gapCSS } from './variations/_gap/base';\nimport type { ChipGroupProps } from './ChipGroup.types';\nimport { classes } from './ChipGroup.tokens';\n\nexport const chipGroupRoot = (Root: RootProps<HTMLDivElement, ChipGroupProps>) =>\n    forwardRef<HTMLDivElement, ChipGroupProps>((props, ref) => {\n        const { children, view, size, className, isWrapped, gap = 'dense', isCommonChipStyles = true, ...rest } = props;\n\n        const overrideStylesClass = isCommonChipStyles ? classes.chipGroupOverrideStyles : undefined;\n        const wrappedClass = isWrapped ? classes.wrap : undefined;\n\n        return (\n            <Root\n                ref={ref}\n                view={view}\n                size={size}\n                gap={gap}\n                className={cx(overrideStylesClass, wrappedClass, className)}\n                {...rest}\n            >\n                {children}\n            </Root>\n        );\n    });\n\nexport const chipGroupConfig = {\n    name: 'ChipGroup',\n    tag: 'div',\n    layout: chipGroupRoot,\n    base,\n    variations: {\n        view: {\n            css: viewCSS,\n        },\n        size: {\n            css: sizeCSS,\n        },\n        gap: {\n            css: gapCSS,\n        },\n    },\n    defaults: {\n        view: 'primary',\n        size: 'm',\n        gap: 'dense',\n    },\n};\n"],"names":["chipGroupRoot","Root","forwardRef","props","ref","children","view","size","className","isWrapped","_props$gap","gap","_props$isCommonChipSt","isCommonChipStyles","rest","_objectWithoutProperties","_excluded","overrideStylesClass","classes","chipGroupOverrideStyles","undefined","wrappedClass","wrap","React","createElement","_extends","cx","chipGroupConfig","name","tag","layout","base","variations","css","viewCSS","sizeCSS","gapCSS","defaults"],"mappings":";;;;;;;;;;;;;;IAYaA,aAAa,GAAG,SAAhBA,aAAaA,CAAIC,IAA+C,EAAA;AAAA,EAAA,oBACzEC,gBAAU,CAAiC,UAACC,KAAK,EAAEC,GAAG,EAAK;AACvD,IAAA,IAAQC,QAAQ,GAA0FF,KAAK,CAAvGE,QAAQ;MAAEC,IAAI,GAAoFH,KAAK,CAA7FG,IAAI;MAAEC,IAAI,GAA8EJ,KAAK,CAAvFI,IAAI;MAAEC,SAAS,GAAmEL,KAAK,CAAjFK,SAAS;MAAEC,SAAS,GAAwDN,KAAK,CAAtEM,SAAS;MAAAC,UAAA,GAAwDP,KAAK,CAA3DQ,GAAG;AAAHA,MAAAA,GAAG,GAAAD,UAAA,KAAG,KAAA,CAAA,GAAA,OAAO,GAAAA,UAAA;MAAAE,qBAAA,GAAyCT,KAAK,CAA5CU,kBAAkB;AAAlBA,MAAAA,kBAAkB,GAAAD,qBAAA,KAAG,KAAA,CAAA,GAAA,IAAI,GAAAA,qBAAA;AAAKE,MAAAA,IAAI,GAAAC,iDAAA,CAAKZ,KAAK,EAAAa,SAAA,CAAA,CAAA;IAE/G,IAAMC,mBAAmB,GAAGJ,kBAAkB,GAAGK,wBAAO,CAACC,uBAAuB,GAAGC,SAAS,CAAA;IAC5F,IAAMC,YAAY,GAAGZ,SAAS,GAAGS,wBAAO,CAACI,IAAI,GAAGF,SAAS,CAAA;AAEzD,IAAA,oBACIG,KAAA,CAAAC,aAAA,CAACvB,IAAI,EAAAwB,iCAAA,CAAA;AACDrB,MAAAA,GAAG,EAAEA,GAAI;AACTE,MAAAA,IAAI,EAAEA,IAAK;AACXC,MAAAA,IAAI,EAAEA,IAAK;AACXI,MAAAA,GAAG,EAAEA,GAAI;AACTH,MAAAA,SAAS,EAAEkB,QAAE,CAACT,mBAAmB,EAAEI,YAAY,EAAEb,SAAS,CAAA;KACtDM,EAAAA,IAAI,CAEPT,EAAAA,QACC,CAAC,CAAA;AAEf,GAAC,CAAC,CAAA;AAAA,EAAA;AAEC,IAAMsB,eAAe,GAAG;AAC3BC,EAAAA,IAAI,EAAE,WAAW;AACjBC,EAAAA,GAAG,EAAE,KAAK;AACVC,EAAAA,MAAM,EAAE9B,aAAa;AACrB+B,EAAAA,IAAI,EAAJA,qBAAI;AACJC,EAAAA,UAAU,EAAE;AACR1B,IAAAA,IAAI,EAAE;AACF2B,MAAAA,GAAG,EAAEC,SAAAA;KACR;AACD3B,IAAAA,IAAI,EAAE;AACF0B,MAAAA,GAAG,EAAEE,WAAAA;KACR;AACDxB,IAAAA,GAAG,EAAE;AACDsB,MAAAA,GAAG,EAAEG,WAAAA;AACT,KAAA;GACH;AACDC,EAAAA,QAAQ,EAAE;AACN/B,IAAAA,IAAI,EAAE,SAAS;AACfC,IAAAA,IAAI,EAAE,GAAG;AACTI,IAAAA,GAAG,EAAE,OAAA;AACT,GAAA;AACJ;;;;;"}

package/cjs/components/ChipGroup/ChipGroup.styles.js

@@ -1,9 +0,0 @@
-import './ChipGroup.styles_1l3nd6v.css';
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var base = "bzgm0e4";
-
-exports.base = base;
-//# sourceMappingURL=ChipGroup.styles.js.map

package/cjs/components/ChipGroup/ChipGroup.styles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChipGroup.styles.js","sources":["../../../src/components/ChipGroup/ChipGroup.styles.ts"],"sourcesContent":["import { css } from '@linaria/core';\n\nimport { classes } from './ChipGroup.tokens';\n\nexport const base = css`\n    display: inline-flex;\n\n    &.${classes.wrap} {\n        flex-wrap: wrap;\n    }\n`;\n"],"names":["base"],"mappings":";;;;AAIO,IAAMA,IAAI,GAMhB;;;;"}

package/cjs/components/ChipGroup/ChipGroup.styles_1l3nd6v.css

@@ -1 +0,0 @@
-.bzgm0e4{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;}.bzgm0e4.chip-group-wrap{-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;}

package/cjs/components/ChipGroup/ChipGroup.tokens.js

@@ -1,50 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var classes = {
-  chipGroupOverrideStyles: 'chip-group-override-styles',
-  dense: 'chip-group-gap-dense',
-  wide: 'chip-group-gap-wide',
-  wrap: 'chip-group-wrap'
-};
-var tokens = {
-  chipBackground: '--plasma-chip-group-items-background',
-  chipColor: '--plasma-chip-group-items-color',
-  chipBackgroundHover: '--plasma-chip-group-items-background-hover',
-  chipColorHover: '--plasma-chip-group-items-color-hover',
-  chipScaleHover: '--plasma-chip-group-items-scale-hover',
-  chipBackgroundActive: '--plasma-chip-group-items-background-active',
-  chipColorActive: '--plasma-chip-group-items-color-active',
-  chipScaleActive: '--plasma-chip-group-items-scale-active',
-  chipFocusColor: '--plasma-chip-group-items-focus-color',
-  chipOutlineSize: '--plasma-chip-group-items-outline-size',
-  chipCloseIconColor: '--plasma-chip-group-items-close-icon-color',
-  chipCloseIconColorHover: '--plasma-chip-group-items-close-icon-color-hover',
-  chipCloseIconColorActive: '--plasma-chip-group-items-close-icon-color-active',
-  chipGroupItemsGap: '--plasma-chip-group-items-gap',
-  chipBorderRadius: '--plasma-chip-group-items-border-radius',
-  chipHeight: '--plasma-chip-group-item-height',
-  chipWidth: '--plasma-chip-group-item-width',
-  chipPaddingTop: '--plasma-chip-group-item-padding-top',
-  chipPaddingRight: '--plasma-chip-group-item-padding-right',
-  chipPaddingBottom: '--plasma-chip-group-item-padding-bottom',
-  chipPaddingLeft: '--plasma-chip-group-item-padding-left',
-  chipCloseIconSize: '--plasma-chip-group-item-close-icon-size',
-  chipFontFamily: '--plasma-chip-group-item-font-family',
-  chipFontSize: '--plasma-chip-group-item-font-size',
-  chipFontStyle: '--plasma-chip-group-item-font-style',
-  chipFontWeight: '--plasma-chip-group-item-font-weight',
-  chipLetterSpacing: '--plasma-chip-group-item-letter-spacing',
-  chipLineHeight: '--plasma-chip-group-item-line-height',
-  chipLeftContentMarginLeft: '--plasma-chip-group-item-left-content-margin-left',
-  chipLeftContentMarginRight: '--plasma-chip-group-item-left-content-margin-right',
-  chipRightContentMarginLeft: '--plasma-chip-group-item-right-content-margin-left',
-  chipRightContentMarginRight: '--plasma-chip-group-item-right-content-margin-right',
-  chipClearContentMarginLeft: '--plasma-chip-group-item-clear-content-margin-left',
-  chipClearContentMarginRight: '--plasma-chip-group-item-clear-content-margin-right'
-};
-
-exports.classes = classes;
-exports.tokens = tokens;
-//# sourceMappingURL=ChipGroup.tokens.js.map