@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/dist/header/tray-icon.js

@@ -2,7 +2,7 @@ import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBa
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-import Button from '../button/button.js';
+import ThemedButton from '../button/button.js';
 import { m as modules_47759f5e } from '../_helpers/header.js';
 import 'focus-visible';
 import '@jetbrains/icons/chevron-10px';
@@ -27,19 +27,16 @@ class TrayIcon extends Component {
       [modules_47759f5e.rotatable]: rotatable,
       [modules_47759f5e.rotated]: rotatable && restProps.active
     });
-    return /*#__PURE__*/React.createElement(Button, _extends({}, restProps, {
+    return /*#__PURE__*/React.createElement(ThemedButton, _extends({}, restProps, {
       className: classes
     }));
   }
 
 }
 
-_defineProperty(TrayIcon, "propTypes", { ...Button.propTypes,
+_defineProperty(TrayIcon, "propTypes", { ...ThemedButton.propTypes,
   icon: PropTypes.oneOfType([PropTypes.string, PropTypes.elementType]).isRequired,
   rotatable: PropTypes.bool
 });
 
-_defineProperty(TrayIcon, "defaultProps", { ...Button.defaultProps
-});
-
 export { TrayIcon as default };

package/dist/header/tray.d.ts

@@ -0,0 +1,9 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export default class Tray extends Component<HTMLAttributes<HTMLElement>> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    render(): JSX.Element;
+}

package/dist/heading/heading.d.ts

@@ -0,0 +1,25 @@
+import React, { HTMLAttributes } from 'react';
+/**
+ * @name Heading
+ */
+export declare enum Levels {
+    H1 = 1,
+    H2 = 2,
+    H3 = 3,
+    H4 = 4
+}
+export interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+    level?: Levels | undefined;
+}
+declare const Heading: React.ComponentType<HeadingProps> & {
+    Levels: typeof Levels;
+};
+export default Heading;
+export interface H1Props extends HTMLAttributes<HTMLHeadingElement> {
+    caps?: boolean | null | undefined;
+}
+declare const H1: React.ComponentType<H1Props>;
+declare const H2: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const H3: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const H4: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+export { H1, H2, H3, H4 };

package/dist/heading/heading.js

@@ -10,18 +10,21 @@ var modules_901b77ec = {"heading":"heading_rui_f244 font_rui_750f","caps":"caps_
  * @name Heading
  */
 
-const Levels = {
-  H1: 1,
-  H2: 2,
-  H3: 3,
-  H4: 4
-};
+var Levels;
+
+(function (Levels) {
+  Levels[Levels["H1"] = 1] = "H1";
+  Levels[Levels["H2"] = 2] = "H2";
+  Levels[Levels["H3"] = 3] = "H3";
+  Levels[Levels["H4"] = 4] = "H4";
+})(Levels || (Levels = {}));
+
 const fallbackHeading = deprecate(() => 'h3', 'Headings of level 5 and higher are replaced with h3');
-const Heading = /*#__PURE__*/memo(function Heading(_ref) {
+const HeadingMemo = /*#__PURE__*/memo(function Heading(_ref) {
   let {
     children,
     className,
-    level,
+    level = Levels.H1,
     ...restProps
   } = _ref;
   const classes = classNames(modules_901b77ec.heading, className);
@@ -30,13 +33,11 @@ const Heading = /*#__PURE__*/memo(function Heading(_ref) {
     className: classes
   }), children);
 });
+const Heading = HeadingMemo;
 Heading.propTypes = {
   children: PropTypes.node,
   className: PropTypes.string,
-  level: PropTypes.number
-};
-Heading.defaultProps = {
-  level: Levels.H1
+  level: PropTypes.oneOf([Levels.H1, Levels.H2, Levels.H3, Levels.H4])
 };
 Heading.Levels = Levels;
 
@@ -70,4 +71,4 @@ const H2 = makeHeading(Levels.H2);
 const H3 = makeHeading(Levels.H3);
 const H4 = makeHeading(Levels.H4);
 
-export { H1, H2, H3, H4, Heading as default };
+export { H1, H2, H3, H4, Levels, Heading as default };

package/dist/http/http.d.ts

@@ -0,0 +1,49 @@
+import ExtendableError from 'es6-error';
+export declare const defaultFetchConfig: RequestInit;
+export interface HTTPErrorData {
+    error?: string;
+}
+export declare class HTTPError extends ExtendableError {
+    data: HTTPErrorData;
+    status: number | undefined;
+    constructor(response: Partial<Response>, data?: HTTPErrorData);
+}
+export declare const CODE: {
+    UNAUTHORIZED: number;
+};
+export interface FetchParams<T = unknown> extends Omit<RequestInit, 'body'> {
+    body?: T;
+    query?: Record<string, unknown> | undefined;
+}
+export declare type RequestParams = FetchParams & {
+    sendRawBody?: false;
+} | FetchParams<BodyInit | null> & {
+    sendRawBody: true;
+};
+export interface HTTPAuth {
+    requestToken(): Promise<string | null> | string | null;
+    forceTokenUpdate(): Promise<string | null>;
+}
+export default class HTTP implements Partial<HTTPAuth> {
+    baseUrl: string | null | undefined;
+    _requestsMeta: WeakMap<object, Partial<Response>>;
+    fetchConfig: RequestInit;
+    requestToken?: () => Promise<string | null> | string | null;
+    shouldRefreshToken?: (error: string) => boolean;
+    forceTokenUpdate?: () => Promise<string | null>;
+    constructor(auth?: HTTPAuth, baseUrl?: string | null | undefined, fetchConfig?: RequestInit);
+    setAuth: (auth: HTTPAuth) => void;
+    setBaseUrl: (baseUrl: string | null | undefined) => void;
+    _fetch(...args: Parameters<typeof fetch>): Promise<Response> | Partial<Response>;
+    private _makeRequestUrl;
+    private _performRequest;
+    private _storeRequestMeta;
+    private _processResponse;
+    private static _isErrorStatus;
+    fetch: (url: string, params?: FetchParams) => Promise<any>;
+    authorizedFetch(...args: Parameters<HTTP['_performRequest']>): Promise<any>;
+    request: (url: string, params?: RequestParams | undefined) => Promise<any>;
+    getMetaForResponse: (response: object) => Partial<Response> | undefined;
+    get: (url: string, params?: RequestParams | undefined) => Promise<any>;
+    post: (url: string, params?: RequestParams | undefined) => Promise<any>;
+}

package/dist/http/http.js

@@ -20,6 +20,11 @@ class HTTPError extends ExtendableError {
   constructor(response) {
     let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     super(`${response.status} ${response.statusText || ''}`);
+
+    _defineProperty(this, "data", void 0);
+
+    _defineProperty(this, "status", void 0);
+
     this.data = data;
     this.status = response.status;
   }
@@ -38,6 +43,14 @@ class HTTP {
 
     _defineProperty(this, "_requestsMeta", new WeakMap());
 
+    _defineProperty(this, "fetchConfig", void 0);
+
+    _defineProperty(this, "requestToken", void 0);
+
+    _defineProperty(this, "shouldRefreshToken", void 0);
+
+    _defineProperty(this, "forceTokenUpdate", void 0);
+
     _defineProperty(this, "setAuth", auth => {
       this.requestToken = () => auth.requestToken();
 
@@ -58,27 +71,33 @@ class HTTP {
         ...fetchConfig
       } = params;
       const response = await _this._fetch(_this._makeRequestUrl(url, query), { ...fetchConfig,
-        body: body ? JSON.stringify(body) : body
+        body: body !== null && body !== undefined && body !== '' ? JSON.stringify(body) : body
       });
       return _this._processResponse(response);
     });
 
     _defineProperty(this, "request", async (url, params) => {
-      let token = await this.requestToken();
+      var _this$requestToken;
+
+      let token = await ((_this$requestToken = this.requestToken) === null || _this$requestToken === void 0 ? void 0 : _this$requestToken.call(this));
       let response = await this._performRequest(url, token, params);
 
       try {
         // Wait for result to catch an HTTP error
         return await this._processResponse(response);
       } catch (error) {
+        var _this$shouldRefreshTo;
+
         if (!(error instanceof HTTPError)) {
           throw error;
         }
 
-        const shouldRefreshToken = error.data.error !== undefined ? this.shouldRefreshToken(error.data.error) : false;
+        const shouldRefreshToken = error.data.error !== undefined ? (_this$shouldRefreshTo = this.shouldRefreshToken) === null || _this$shouldRefreshTo === void 0 ? void 0 : _this$shouldRefreshTo.call(this, error.data.error) : false;
 
         if (shouldRefreshToken) {
-          token = await this.forceTokenUpdate();
+          var _this$forceTokenUpdat;
+
+          token = await ((_this$forceTokenUpdat = this.forceTokenUpdate) === null || _this$forceTokenUpdat === void 0 ? void 0 : _this$forceTokenUpdat.call(this));
           response = await this._performRequest(url, token, params);
           return this._processResponse(response);
         }
@@ -140,15 +159,25 @@ class HTTP {
       } : {}),
       ...headers
     };
-    Object.keys(combinedHeaders).forEach(key => {
-      if (combinedHeaders[key] === null || combinedHeaders[key] === undefined) {
+    Object.entries(combinedHeaders).forEach(_ref => {
+      let [key, header] = _ref;
+
+      if (header === null || header === undefined) {
         Reflect.deleteProperty(combinedHeaders, key);
       }
     });
+    let bodyToSend;
+
+    if (params.sendRawBody) {
+      bodyToSend = params.body;
+    } else {
+      bodyToSend = params.body === null || params.body === undefined || params.body === '' ? params.body : JSON.stringify(body);
+    }
+
     return this._fetch(this._makeRequestUrl(url, query), { ...this.fetchConfig,
       headers: combinedHeaders,
       ...fetchConfig,
-      body: body && !sendRawBody ? JSON.stringify(body) : body
+      body: bodyToSend
     });
   }
 
@@ -175,14 +204,18 @@ class HTTP {
   }
 
   async _processResponse(response) {
-    const contentType = response.headers.get('content-type');
+    var _response$headers;
+
+    const contentType = (_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers.get('content-type');
     const isJson = contentType && contentType.indexOf('application/json') !== -1;
 
-    if (HTTP._isErrorStatus(response.status)) {
+    if (response.status != null && HTTP._isErrorStatus(response.status)) {
       let resJson;
 
       try {
-        resJson = await (isJson ? response.json() : response.text());
+        var _response$json, _response$text;
+
+        resJson = await (isJson ? (_response$json = response.json) === null || _response$json === void 0 ? void 0 : _response$json.call(response) : (_response$text = response.text) === null || _response$text === void 0 ? void 0 : _response$text.call(response));
       } catch (err) {// noop
       }
 
@@ -190,8 +223,10 @@ class HTTP {
     }
 
     try {
-      const parsedResponse = await (isJson ? response.json() : {
-        data: await response.text()
+      var _response$json2, _response$text2;
+
+      const parsedResponse = await (isJson ? (_response$json2 = response.json) === null || _response$json2 === void 0 ? void 0 : _response$json2.call(response) : {
+        data: await ((_response$text2 = response.text) === null || _response$text2 === void 0 ? void 0 : _response$text2.call(response))
       });
 
       this._storeRequestMeta(parsedResponse, response);

package/dist/http/http.mock.d.ts

@@ -0,0 +1,20 @@
+import HTTP, { FetchParams } from './http';
+export interface HTTPMockRequest {
+    url: string;
+    params: FetchParams;
+}
+export default class HTTPMock extends HTTP {
+    defaultResponse: unknown;
+    requests: HTTPMockRequest[];
+    responsesByUrlMap: Map<string | RegExp, unknown>;
+    constructor();
+    _fetch(url: string, params: RequestInit): {
+        status: number;
+        headers: Headers;
+        json: () => Promise<unknown>;
+    };
+    respondDefault(response: unknown): void;
+    respondForUrl(url: string | RegExp, response: unknown): void;
+    _getResponseForUrl(urlToMatch: string): unknown;
+    getRequestsByUrlPart(url: string): HTTPMockRequest[];
+}

package/dist/http/http.mock.js

@@ -1,16 +1,23 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import HTTP from './http.js';
-import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'es6-error';
 import '../global/url.js';
 
 const authMock = {
   requestToken: () => 'mock token',
   shouldRefreshToken: () => false,
-  forceTokenUpdate: async () => {}
+  forceTokenUpdate: () => Promise.resolve(null)
 };
 class HTTPMock extends HTTP {
   constructor() {
     super(authMock);
+
+    _defineProperty(this, "defaultResponse", void 0);
+
+    _defineProperty(this, "requests", void 0);
+
+    _defineProperty(this, "responsesByUrlMap", void 0);
+
     this.defaultResponse = null;
     this.requests = [];
     this.responsesByUrlMap = new Map();
@@ -20,7 +27,7 @@ class HTTPMock extends HTTP {
     this.requests = [...this.requests, {
       url,
       params: { ...params,
-        body: params.body ? JSON.parse(params.body) : params.body
+        body: typeof params.body === 'string' ? JSON.parse(params.body) : params.body
       }
     }];
     return {
@@ -28,7 +35,7 @@ class HTTPMock extends HTTP {
       headers: new Headers({
         'content-type': 'application/json'
       }),
-      json: () => this._getResponseForUrl(url) || this.defaultResponse
+      json: () => Promise.resolve(this._getResponseForUrl(url) || this.defaultResponse)
     };
   }
 
@@ -48,7 +55,7 @@ class HTTPMock extends HTTP {
         return this.responsesByUrlMap.get(url);
       }
 
-      if (url.test && url.test(urlToMatch)) {
+      if (url instanceof RegExp && url.test(urlToMatch)) {
         return this.responsesByUrlMap.get(url);
       }
     }

package/dist/hub-source/hub-source.d.ts

@@ -0,0 +1,42 @@
+import Auth from '../auth/auth';
+import HTTP from '../http/http';
+export interface Item {
+    name: string;
+}
+export declare type Response<I extends Item, U extends string> = Partial<Record<U, I[]>> & {
+    total: number;
+};
+export interface HubSourceOptions {
+    searchMax: number;
+    searchSideThreshold: number;
+    queryFormatter: (query: string) => string;
+}
+/**
+ * HubSource is designed to speed up search requests for small installations.
+ * If there are less than "searchSideThreshold" items, it uses client-side filtering
+ * of cached results to greatly increase search speed. Useful for completion and
+ * select data source.
+ */
+export default class HubSource<I extends Item, U extends string> {
+    static TOP_ALL: number;
+    http: HTTP;
+    relativeUrl: U;
+    options: HubSourceOptions;
+    storedData: Response<I, U> | null;
+    isClientSideSearch: boolean | null;
+    filterFn: (item: I) => boolean;
+    constructor(auth: Auth, relativeUrl: U, options?: Partial<HubSourceOptions>);
+    makeRequest(queryParams?: Record<string, unknown>): Promise<any>;
+    makeCachedRequest(params?: Record<string, unknown>): Promise<any>;
+    static mergeParams(params?: Record<string, unknown>, toMerge?: Record<string, unknown>): Record<string, unknown>;
+    checkIsClientSideSearch(res: Response<I, U>): boolean;
+    getDefaultFilterFn(query?: string): (it: I) => boolean;
+    formatQuery(query?: string): string;
+    static validateInputParams(params: Record<string, unknown>): void;
+    processResults(res: Response<I, U>): I[];
+    sideDetectionRequest(params?: Record<string, unknown>, query?: string): Promise<any>;
+    doClientSideSearch(params?: Record<string, unknown>): Promise<any>;
+    doServerSideSearch(params?: Record<string, unknown>, query?: string): Promise<any>;
+    getValueFromSuitableSource(query?: string, params?: Record<string, unknown>): Promise<any>;
+    get(query: string, params: Record<string, unknown>, filterFn?: (item: I) => boolean): Promise<I[]>;
+}

package/dist/hub-source/hub-source.js

@@ -14,12 +14,25 @@ const defaultOptions = {
 
 class HubSource {
   constructor(auth, relativeUrl, options) {
+    _defineProperty(this, "http", void 0);
+
+    _defineProperty(this, "relativeUrl", void 0);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "storedData", void 0);
+
+    _defineProperty(this, "isClientSideSearch", void 0);
+
+    _defineProperty(this, "filterFn", void 0);
+
     this.http = auth.http;
     this.relativeUrl = relativeUrl;
     this.options = Object.assign({}, defaultOptions, options);
     this.storedData = null;
     this.isClientSideSearch = null;
-    this.filterFn = null;
+
+    this.filterFn = () => true;
   }
 
   makeRequest(queryParams) {

package/dist/hub-source/hub-source__user.d.ts

@@ -0,0 +1,4 @@
+import Auth, { AuthUser } from '../auth/auth';
+import { UserCardUser } from '../user-card/card';
+export declare function convertUserForCard(hubUser: AuthUser, serverUri?: string): UserCardUser;
+export declare function createHubUserCardSource(auth: Auth, userId: string | number, fields?: string): () => Promise<UserCardUser>;

package/dist/hub-source/hub-source__user.js

@@ -5,14 +5,16 @@ import '../global/url.js';
 
 const DEFAULT_FIELDS = 'id,name,login,banned,banReason,profile(email/email,avatar/url)';
 function convertUserForCard(hubUser) {
+  var _hubUser$profile, _hubUser$profile$emai, _hubUser$profile2, _hubUser$profile2$ava;
+
   let serverUri = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
   return {
     name: hubUser.name,
     login: hubUser.login,
     banned: hubUser.banned,
     banReason: hubUser.banReason,
-    email: hubUser.profile.email && hubUser.profile.email.email,
-    avatarUrl: hubUser.profile.avatar.url,
+    email: (_hubUser$profile = hubUser.profile) === null || _hubUser$profile === void 0 ? void 0 : (_hubUser$profile$emai = _hubUser$profile.email) === null || _hubUser$profile$emai === void 0 ? void 0 : _hubUser$profile$emai.email,
+    avatarUrl: (_hubUser$profile2 = hubUser.profile) === null || _hubUser$profile2 === void 0 ? void 0 : (_hubUser$profile2$ava = _hubUser$profile2.avatar) === null || _hubUser$profile2$ava === void 0 ? void 0 : _hubUser$profile2$ava.url,
     href: `${serverUri}users/${hubUser.id}`
   };
 }

package/dist/hub-source/hub-source__users-groups.d.ts

@@ -0,0 +1,24 @@
+import Auth, { AuthUser } from '../auth/auth';
+import HubSource, { Item } from './hub-source';
+export interface HubSourceUsersGroupsOptions {
+    searchMax: number;
+    searchSideThreshold: number;
+}
+export interface UserGroup extends Item {
+    id: number;
+    total?: number;
+    userCount: number;
+    iconUrl?: string;
+}
+export default class HubSourceUsersGroups {
+    auth: Auth;
+    options: HubSourceUsersGroupsOptions;
+    usersSource: HubSource<AuthUser, 'users'>;
+    groupsSource: HubSource<UserGroup, 'usergroups'>;
+    constructor(auth: Auth, options?: Partial<HubSourceUsersGroupsOptions>);
+    static wrapMultiwordQuery(query?: string): string | undefined;
+    createUsersFilterFn(query?: string): (it: AuthUser) => boolean;
+    getUsers(query?: string): Promise<AuthUser[]>;
+    getGroups(query?: string): Promise<UserGroup[]>;
+    getUserAndGroups(query?: string): Promise<[AuthUser[], UserGroup[]]>;
+}

package/dist/hub-source/hub-source__users-groups.js

@@ -1,5 +1,5 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import HubSource from './hub-source.js';
-import '../_helpers/_rollupPluginBabelHelpers.js';
 
 const defaultOptions = {
   searchMax: 20,
@@ -7,6 +7,14 @@ const defaultOptions = {
 };
 class HubSourceUsersGroups {
   constructor(auth, options) {
+    _defineProperty(this, "auth", void 0);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "usersSource", void 0);
+
+    _defineProperty(this, "groupsSource", void 0);
+
     this.auth = auth;
     this.options = Object.assign({}, defaultOptions, options);
     this.usersSource = new HubSource(auth, 'users', {

package/dist/icon/icon.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @name Icon
+ */
+import { PureComponent, ComponentType, SVGAttributes, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Color, Size } from './icon__constants';
+export declare type IconType = ComponentType<SVGAttributes<SVGSVGElement>>;
+export interface IconProps extends HTMLAttributes<HTMLElement> {
+    color: Color;
+    glyph: string | IconType | null;
+    height?: number | undefined;
+    size?: Size | null | undefined;
+    width?: number | undefined;
+    loading?: boolean | null | undefined;
+    suppressSizeWarning?: boolean | null | undefined;
+}
+export default class Icon extends PureComponent<IconProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        color: PropTypes.Requireable<string>;
+        glyph: PropTypes.Validator<PropTypes.ReactComponentLike>;
+        height: PropTypes.Requireable<number>;
+        size: PropTypes.Requireable<number>;
+        width: PropTypes.Requireable<number>;
+        loading: PropTypes.Requireable<boolean>;
+        suppressSizeWarning: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        className: string;
+        color: Color;
+        glyph: string;
+    };
+    static Color: typeof Color;
+    static Size: typeof Size;
+    warnSize(): void;
+    getStyle(): {
+        width: number | undefined;
+        height: number | undefined;
+    } | undefined;
+    render(): JSX.Element | null;
+}
+export declare type IconAttrs = JSX.LibraryManagedAttributes<typeof Icon, IconProps>;
+export { Color, Size };

package/dist/icon/icon.js

@@ -4,7 +4,7 @@ import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import deprecate from 'util-deprecate';
 import { Color, Size } from './icon__constants.js';
-export { Size } from './icon__constants.js';
+export { Color, Size } from './icon__constants.js';
 import { m as modules_29747b80 } from '../_helpers/icon.js';
 import IconSVG from './icon__svg.js';
 import '../global/memoize.js';
@@ -44,7 +44,7 @@ class Icon extends PureComponent {
       };
     }
 
-    return null;
+    return undefined;
   }
 
   render() {

package/dist/icon/icon__constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Commonly used icon colors.
+ * @enum {string}
+ */
+export declare enum Color {
+    BLUE = "blue",
+    DEFAULT = "",
+    GRAY = "gray",
+    GREEN = "green",
+    MAGENTA = "magenta",
+    RED = "red",
+    WHITE = "white"
+}
+/**
+ * @enum {number}
+ */
+export declare enum Size {
+    Size12 = 12,
+    Size14 = 14,
+    Size16 = 16,
+    Size18 = 18,
+    Size20 = 20,
+    Size24 = 24,
+    Size32 = 32,
+    Size40 = 40,
+    Size48 = 48,
+    Size64 = 64,
+    Size96 = 96,
+    Size128 = 128
+}

package/dist/icon/icon__constants.js

@@ -2,32 +2,37 @@
  * Commonly used icon colors.
  * @enum {string}
  */
-const Color = {
-  BLUE: 'blue',
-  DEFAULT: '',
-  GRAY: 'gray',
-  GREEN: 'green',
-  MAGENTA: 'magenta',
-  RED: 'red',
-  WHITE: 'white'
-};
+var Color;
+
+(function (Color) {
+  Color["BLUE"] = "blue";
+  Color["DEFAULT"] = "";
+  Color["GRAY"] = "gray";
+  Color["GREEN"] = "green";
+  Color["MAGENTA"] = "magenta";
+  Color["RED"] = "red";
+  Color["WHITE"] = "white";
+})(Color || (Color = {}));
 /**
  * @enum {number}
  */
 
-const Size = {
-  Size12: 12,
-  Size14: 14,
-  Size16: 16,
-  Size18: 18,
-  Size20: 20,
-  Size24: 24,
-  Size32: 32,
-  Size40: 40,
-  Size48: 48,
-  Size64: 64,
-  Size96: 96,
-  Size128: 128
-};
+
+var Size;
+
+(function (Size) {
+  Size[Size["Size12"] = 12] = "Size12";
+  Size[Size["Size14"] = 14] = "Size14";
+  Size[Size["Size16"] = 16] = "Size16";
+  Size[Size["Size18"] = 18] = "Size18";
+  Size[Size["Size20"] = 20] = "Size20";
+  Size[Size["Size24"] = 24] = "Size24";
+  Size[Size["Size32"] = 32] = "Size32";
+  Size[Size["Size40"] = 40] = "Size40";
+  Size[Size["Size48"] = 48] = "Size48";
+  Size[Size["Size64"] = 64] = "Size64";
+  Size[Size["Size96"] = 96] = "Size96";
+  Size[Size["Size128"] = 128] = "Size128";
+})(Size || (Size = {}));
 
 export { Color, Size };