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

package/components/global/get-event-key.js

@@ -1,112 +1,100 @@
-// react-dom getEventKey function extracted
-
 const normalizeKey = {
-  Esc: 'Escape',
-  Spacebar: ' ',
-  Left: 'ArrowLeft',
-  Up: 'ArrowUp',
-  Right: 'ArrowRight',
-  Down: 'ArrowDown',
-  Del: 'Delete',
-  Win: 'OS',
-  Menu: 'ContextMenu',
-  Apps: 'ContextMenu',
-  Scroll: 'ScrollLock',
-  MozPrintableKey: 'Unidentified'
+    Esc: 'Escape',
+    Spacebar: ' ',
+    Left: 'ArrowLeft',
+    Up: 'ArrowUp',
+    Right: 'ArrowRight',
+    Down: 'ArrowDown',
+    Del: 'Delete',
+    Win: 'OS',
+    Menu: 'ContextMenu',
+    Apps: 'ContextMenu',
+    Scroll: 'ScrollLock',
+    MozPrintableKey: 'Unidentified'
 };
-
 const translateToKey = {
-  8: 'Backspace',
-  9: 'Tab',
-  12: 'Clear',
-  13: 'Enter',
-  16: 'Shift',
-  17: 'Control',
-  18: 'Alt',
-  19: 'Pause',
-  20: 'CapsLock',
-  27: 'Escape',
-  32: ' ',
-  33: 'PageUp',
-  34: 'PageDown',
-  35: 'End',
-  36: 'Home',
-  37: 'ArrowLeft',
-  38: 'ArrowUp',
-  39: 'ArrowRight',
-  40: 'ArrowDown',
-  45: 'Insert',
-  46: 'Delete',
-  112: 'F1',
-  113: 'F2',
-  114: 'F3',
-  115: 'F4',
-  116: 'F5',
-  117: 'F6',
-  118: 'F7',
-  119: 'F8',
-  120: 'F9',
-  121: 'F10',
-  122: 'F11',
-  123: 'F12',
-  144: 'NumLock',
-  145: 'ScrollLock',
-  224: 'Meta'
+    8: 'Backspace',
+    9: 'Tab',
+    12: 'Clear',
+    13: 'Enter',
+    16: 'Shift',
+    17: 'Control',
+    18: 'Alt',
+    19: 'Pause',
+    20: 'CapsLock',
+    27: 'Escape',
+    32: ' ',
+    33: 'PageUp',
+    34: 'PageDown',
+    35: 'End',
+    36: 'Home',
+    37: 'ArrowLeft',
+    38: 'ArrowUp',
+    39: 'ArrowRight',
+    40: 'ArrowDown',
+    45: 'Insert',
+    46: 'Delete',
+    112: 'F1',
+    113: 'F2',
+    114: 'F3',
+    115: 'F4',
+    116: 'F5',
+    117: 'F6',
+    118: 'F7',
+    119: 'F8',
+    120: 'F9',
+    121: 'F10',
+    122: 'F11',
+    123: 'F12',
+    144: 'NumLock',
+    145: 'ScrollLock',
+    224: 'Meta'
 };
-
 const ENTER = 13;
 const SPACE = 32;
-
 function getEventCharCode(nativeEvent) {
-  let charCode;
-  const keyCode = nativeEvent.keyCode;
-
-  if ('charCode' in nativeEvent) {
-    charCode = nativeEvent.charCode;
-
-    // FF does not set `charCode` for the Enter-key, check against `keyCode`.
-    if (charCode === 0 && keyCode === ENTER) {
-      charCode = ENTER;
+    let charCode;
+    const keyCode = nativeEvent.keyCode;
+    if ('charCode' in nativeEvent) {
+        charCode = nativeEvent.charCode;
+        // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+        if (charCode === 0 && keyCode === ENTER) {
+            charCode = ENTER;
+        }
     }
-  } else {
-    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-    charCode = keyCode;
-  }
-
-  // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
-  // Must not discard the (non-)printable Enter-key.
-  if (charCode >= SPACE || charCode === ENTER) {
-    return charCode;
-  }
-  return 0;
+    else {
+        // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+        charCode = keyCode;
+    }
+    // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+    // Must not discard the (non-)printable Enter-key.
+    if (charCode >= SPACE || charCode === ENTER) {
+        return charCode;
+    }
+    return 0;
 }
-
-
 export default function getEventKey(nativeEvent) {
-  if (nativeEvent.key) {
-    // Normalize inconsistent values reported by browsers due to
-    // implementations of a working draft specification.
-
-    // FireFox implements `key` but returns `MozPrintableKey` for all
-    // printable characters (normalized to `Unidentified`), ignore it.
-    const key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-    if (key !== 'Unidentified') {
-      return key;
+    if (nativeEvent.key) {
+        // Normalize inconsistent values reported by browsers due to
+        // implementations of a working draft specification.
+        // FireFox implements `key` but returns `MozPrintableKey` for all
+        // printable characters (normalized to `Unidentified`), ignore it.
+        const key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if (key !== 'Unidentified') {
+            return key;
+        }
+    }
+    // Browser does not implement `key`, polyfill as much of it as we can.
+    if (nativeEvent.type === 'keypress') {
+        const charCode = getEventCharCode(nativeEvent);
+        // The enter-key is technically both printable and non-printable and can
+        // thus be captured by `keypress`, no other non-printable key should.
+        return charCode === SPACE ? 'Enter' : String.fromCharCode(charCode);
+    }
+    if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+        // While user keyboard layout determines the actual meaning of each
+        // `keyCode` value, almost all function keys have a universal value.
+        return translateToKey[nativeEvent.keyCode] || 'Unidentified';
     }
-  }
-
-  // Browser does not implement `key`, polyfill as much of it as we can.
-  if (nativeEvent.type === 'keypress') {
-    const charCode = getEventCharCode(nativeEvent);
-
-    // The enter-key is technically both printable and non-printable and can
-    // thus be captured by `keypress`, no other non-printable key should.
-    return charCode === SPACE ? 'Enter' : String.fromCharCode(charCode);
-  }
-  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
-    // While user keyboard layout determines the actual meaning of each
-    // `keyCode` value, almost all function keys have a universal value.
-    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
-  }
-  return '';
+    return '';
 }

package/components/global/get-uid.d.ts

@@ -0,0 +1 @@
+export default function getUID(name: string): string;

package/components/global/get-uid.js

@@ -1,15 +1,11 @@
 const idCounters = {};
-
 export default function getUID(name) {
-  if (!name) {
-    throw Error('Argument "name" is required in getUID()');
-  }
-
-  if (!idCounters[name]) {
-    idCounters[name] = 0;
-  }
-
-  const id = String(idCounters[name]++);
-
-  return name + id;
+    if (!name) {
+        throw Error('Argument "name" is required in getUID()');
+    }
+    if (!idCounters[name]) {
+        idCounters[name] = 0;
+    }
+    const id = String(idCounters[name]++);
+    return name + id;
 }

package/components/global/inject-styles.d.ts

@@ -0,0 +1,3 @@
+import type { PropertiesHyphen } from 'csstype';
+export declare const injectStyleSheet: (styles: string) => HTMLStyleElement;
+export declare const injectRuleSet: (selector: string, declarations: PropertiesHyphen) => HTMLStyleElement;

package/components/global/inject-styles.js

@@ -1,13 +1,11 @@
-export const injectStyleSheet = styles => {
-  const styleTag = document.createElement('style');
-  styleTag.setAttribute('type', 'text/css');
-  styleTag.textContent = styles;
-  document.head.appendChild(styleTag);
-  return styleTag;
+export const injectStyleSheet = (styles) => {
+    const styleTag = document.createElement('style');
+    styleTag.setAttribute('type', 'text/css');
+    styleTag.textContent = styles;
+    document.head.appendChild(styleTag);
+    return styleTag;
 };
-
-export const injectRuleSet = (selector, declarations) =>
-  injectStyleSheet(`
+export const injectRuleSet = (selector, declarations) => injectStyleSheet(`
 ${selector} {
   ${Object.entries(declarations).map(([property, value]) => `${property}: ${value};`).join(`
   `)}

package/components/global/linear-function.d.ts

@@ -0,0 +1,6 @@
+export interface LinearFunction {
+    y(x: number): number;
+    x(y: number): number;
+}
+export default function linearFunction(x0: number, y0: number, a: number): LinearFunction;
+export declare function interpolateLinear(x0: number, x1: number, phase: number): number;

package/components/global/linear-function.js

@@ -1,16 +1,13 @@
 export default function linearFunction(x0, y0, a) {
-  return {
-    y(x) {
-      return +y0 + (x - x0) * a;
-    },
-
-    x(y) {
-      return +x0 + (y - y0) / a;
-    }
-  };
+    return {
+        y(x) {
+            return +y0 + (x - x0) * a;
+        },
+        x(y) {
+            return +x0 + (y - y0) / a;
+        }
+    };
 }
-
 export function interpolateLinear(x0, x1, phase) {
-  return linearFunction(x0, x0, phase).y(x1);
+    return linearFunction(x0, x0, phase).y(x1);
 }
-

package/components/global/listeners.d.ts

@@ -0,0 +1,8 @@
+export declare type Handler<PM extends Record<string, [unknown, unknown]>, E extends keyof PM> = (data: PM[E][0]) => PM[E][1] | Promise<PM[E][1]>;
+export default class Listeners<PM extends Record<string, [unknown, unknown]> = Record<string, [void, unknown]>> {
+    _all: Map<keyof PM, Set<Handler<PM, keyof PM>>>;
+    trigger<E extends keyof PM>(...[event, data]: PM[E][0] extends void ? [E] : [E, PM[E][0]]): Promise<PM[E][1][]>;
+    add<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    remove<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    removeAll(): void;
+}

package/components/global/listeners.js

@@ -1,38 +1,27 @@
 export default class Listeners {
-  constructor() {
-    this.removeAll();
-  }
-
-  trigger(event, data) {
-    const handlers = this._all.get(event);
-
-    if (handlers) {
-      return Promise.all([...handlers].map(fn => fn(data)));
+    _all = new Map();
+    trigger(...[event, data]) {
+        const handlers = this._all.get(event);
+        if (handlers) {
+            return Promise.all([...handlers].map(fn => fn(data)));
+        }
+        return Promise.resolve([]);
     }
-
-    return Promise.resolve([]);
-  }
-
-  add(event, handler) {
-    let handlers = this._all.get(event);
-
-    if (!handlers) {
-      handlers = new Set();
-      this._all.set(event, handlers);
+    add(event, handler) {
+        let handlers = this._all.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this._all.set(event, handlers);
+        }
+        handlers.add(handler);
     }
-
-    handlers.add(handler);
-  }
-
-  remove(event, handler) {
-    const handlers = this._all.get(event);
-
-    if (handlers) {
-      handlers.delete(handler);
+    remove(event, handler) {
+        const handlers = this._all.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    removeAll() {
+        this._all = new Map();
     }
-  }
-
-  removeAll() {
-    this._all = new Map();
-  }
 }

package/components/global/memoize.d.ts

@@ -0,0 +1 @@
+export default function memoize<A = void, T = void>(fn: (arg: A) => T): (arg: A) => T;

package/components/global/memoize.js

@@ -1,14 +1,15 @@
 export default function memoize(fn) {
-  const primitiveCache = new Map();
-  const objectCache = new WeakMap();
-  return function memoized(arg = '__singleValue__') {
-    const cache = arg instanceof Object ? objectCache : primitiveCache;
-    if (cache.has(arg)) {
-      return cache.get(arg);
-    }
-
-    const value = fn(arg);
-    cache.set(arg, value);
-    return value;
-  };
+    const primitiveCache = new Map();
+    const objectCache = new WeakMap();
+    return function memoized(arg) {
+        const key = arg ?? '__singleValue__';
+        const cache = key instanceof Object ? objectCache : primitiveCache;
+        const cached = cache.get(key);
+        if (cached != null) {
+            return cached;
+        }
+        const value = fn(arg);
+        cache.set(key, value);
+        return value;
+    };
 }

package/components/global/normalize-indent.d.ts

@@ -0,0 +1 @@
+export default function normalizeIndent(string: string): string;

package/components/global/normalize-indent.js

@@ -1,34 +1,30 @@
 export default function normalizeIndent(string) {
-  const nonemptyRE = /\S/;
-  const indentRE = /^\s*/;
-
-  const lines = string.split(/\n/g);
-  const linesCopy = [...lines];
-
-  //remove empty lines at the beginning and the end
-  for (const line of linesCopy) {
-    if (nonemptyRE.test(line)) {
-      break;
-    } else {
-      lines.shift();
+    const nonemptyRE = /\S/;
+    const indentRE = /^\s*/;
+    const lines = string.split(/\n/g);
+    const linesCopy = [...lines];
+    //remove empty lines at the beginning and the end
+    for (const line of linesCopy) {
+        if (nonemptyRE.test(line)) {
+            break;
+        }
+        else {
+            lines.shift();
+        }
     }
-  }
-
-  for (const line of linesCopy.reverse()) {
-    if (nonemptyRE.test(line)) {
-      break;
-    } else {
-      lines.pop();
+    for (const line of linesCopy.reverse()) {
+        if (nonemptyRE.test(line)) {
+            break;
+        }
+        else {
+            lines.pop();
+        }
     }
-  }
-
-  const indents = lines.
-    filter(line => nonemptyRE.test(line)).
-    map(line => line.match(indentRE)[0].length);
-
-  const minIndent = Math.min(...indents);
-
-  return lines.
-    map(line => line.slice(minIndent)).
-    join('\n');
+    const indents = lines.
+        filter(line => nonemptyRE.test(line)).
+        map(line => line.match(indentRE)?.[0].length ?? 0);
+    const minIndent = Math.min(...indents);
+    return lines.
+        map(line => line.slice(minIndent)).
+        join('\n');
 }

package/components/global/promise-with-timeout.d.ts

@@ -0,0 +1,4 @@
+export interface PromiseWithTimeoutConfig {
+    error?: Error | null | undefined;
+}
+export default function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, { error }: PromiseWithTimeoutConfig): Promise<unknown>;

package/components/global/promise-with-timeout.js

@@ -1,10 +1,8 @@
 // Useful for using fetch with timeout
 // https://github.com/github/fetch/issues/175#issuecomment-284787564
-
-export default function promiseWithTimeout(promise, timeout, {error}) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => reject(error || new Error('Timeout')), timeout);
-
-    promise.then(resolve, reject);
-  });
+export default function promiseWithTimeout(promise, timeout, { error }) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => reject(error || new Error('Timeout')), timeout);
+        promise.then(resolve, reject);
+    });
 }

package/components/global/prop-types.d.ts

@@ -0,0 +1,4 @@
+import PropTypes from 'prop-types';
+export declare const refObject: <T>(value: PropTypes.Validator<T>) => PropTypes.Requireable<PropTypes.InferProps<{
+    current: PropTypes.Validator<T>;
+}>>;

package/components/global/prop-types.js

@@ -0,0 +1,4 @@
+import PropTypes from 'prop-types';
+export const refObject = (value) => PropTypes.shape({
+    current: value
+});

package/components/global/radial-gradient-mask.d.ts

@@ -0,0 +1,9 @@
+import type { PropertiesHyphen } from 'csstype';
+export interface RadialGradientMask {
+    supports: boolean;
+    css: PropertiesHyphen;
+    maskId?: string;
+    svgDefs?: string;
+}
+declare const _default: (length: string, stops: Record<string, string>) => RadialGradientMask;
+export default _default;

package/components/global/radial-gradient-mask.js

@@ -1,26 +1,22 @@
 import getUID from './get-uid';
 import supportsCss from './supports-css';
-
-const radialGradient = (length, stops) =>
-  `radial-gradient(${length}, ${Object.entries(stops).map(entry => entry.join(' ')).join(', ')})`;
-
+const radialGradient = (length, stops) => `radial-gradient(${length}, ${Object.entries(stops).map(entry => entry.join(' ')).join(', ')})`;
 export default (length, stops) => {
-  for (const prefix of ['', '-webkit-']) {
-    const property = `${prefix}mask-image`;
-    const declaration = `${property}: radial-gradient(black, white)`;
-    if (supportsCss(declaration)) {
-      return {
-        supports: true,
-        css: {
-          [property]: radialGradient(length, stops)
+    for (const prefix of ['', '-webkit-']) {
+        const property = `${prefix}mask-image`;
+        const declaration = `${property}: radial-gradient(black, white)`;
+        if (supportsCss(declaration)) {
+            return {
+                supports: true,
+                css: {
+                    [property]: radialGradient(length, stops)
+                }
+            };
         }
-      };
     }
-  }
-
-  const gradientId = getUID('gradient');
-  const maskId = getUID('mask');
-  const svgDefs = `
+    const gradientId = getUID('gradient');
+    const maskId = getUID('mask');
+    const svgDefs = `
     <svg>
       <defs>
         <radialGradient id="${gradientId}">
@@ -34,10 +30,10 @@ export default (length, stops) => {
       </defs>
     </svg>
   `;
-  return {
-    supports: false,
-    css: {},
-    maskId,
-    svgDefs
-  };
+    return {
+        supports: false,
+        css: {},
+        maskId,
+        svgDefs
+    };
 };

package/components/global/react-dom-renderer.d.ts

@@ -0,0 +1,16 @@
+import { Component } from 'react';
+import PropTypes from 'prop-types';
+export interface RendererProps {
+    className?: string | undefined;
+    nodes: readonly Node[];
+}
+export default class Renderer extends Component<RendererProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        nodes: PropTypes.Requireable<any[]>;
+    };
+    componentDidMount(): void;
+    node?: HTMLElement | null;
+    nodeRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/components/global/react-dom-renderer.jsx

@@ -0,0 +1,25 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+export default class Renderer extends Component {
+    static propTypes = {
+        className: PropTypes.string,
+        nodes: PropTypes.array
+    };
+    componentDidMount() {
+        const { nodes } = this.props;
+        if (!this.node || !nodes || !nodes.length) {
+            return;
+        }
+        const fragment = document.createDocumentFragment();
+        nodes.forEach(nodeToRender => fragment.appendChild(nodeToRender));
+        this.node.appendChild(fragment);
+    }
+    node;
+    nodeRef = (node) => {
+        this.node = node;
+    };
+    render() {
+        const { className } = this.props;
+        return (<div className={className} ref={this.nodeRef}/>);
+    }
+}

package/components/global/rerender-hoc.d.ts

@@ -0,0 +1,45 @@
+import { Component } from 'react';
+export interface RerenderableComponent<P, S> extends Component<P, S> {
+    node?: HTMLElement | null;
+}
+export interface RerenderableComponentClass<P, S> {
+    new (props: P): RerenderableComponent<P, S>;
+}
+/**
+ * Wraps a component to add a "rerender" method
+ * @param ComposedComponent
+ * @param captureNode, whether the wrapper should capture this.node itself. Set to false if the component already has "node" property captured
+ * @returns {Rerenderer}
+ */
+export default function rerenderHOC<P, S>(ComposedComponent: RerenderableComponentClass<P, S>): {
+    new (props: P): {
+        _propsCache: Readonly<P> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        rerender(props?: Partial<P>, callback?: (() => void) | undefined): void | Element | Component<P, any, any>;
+        node?: HTMLElement | null | undefined;
+        context: any;
+        setState<K extends keyof S>(state: S | ((prevState: Readonly<S>, props: Readonly<P>) => S | Pick<S, K> | null) | Pick<S, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): import("react").ReactNode;
+        readonly props: Readonly<P> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<S>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): any;
+        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+    };
+};