@jetbrains/ring-ui-built 6.0.1

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

@@ -0,0 +1,101 @@
+var normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+var 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'
+};
+var ENTER = 13;
+var SPACE = 32;
+function getEventCharCode(nativeEvent) {
+  var charCode;
+  var 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;
+}
+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.
+    var 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') {
+    var 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 '';
+}
+
+export { getEventKey as default };

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

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

package/components/global/get-uid.js

@@ -0,0 +1,22 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.concat.js';
+
+var idCounters = {};
+function generateSalt() {
+  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+  return (Date.now() * Math.random()).toString(36).substring(0, 4);
+}
+var salt = generateSalt();
+function getUID(name) {
+  if (!name) {
+    throw Error('Argument "name" is required in getUID()');
+  }
+  if (!idCounters[name]) {
+    idCounters[name] = 0;
+  }
+  var id = String(idCounters[name]++);
+  return "".concat(name).concat(id, "-").concat(salt);
+}
+
+export { getUID as default };

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

@@ -0,0 +1,22 @@
+import { j as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.object.entries.js';
+
+var injectStyleSheet = function injectStyleSheet(styles) {
+  var styleTag = document.createElement('style');
+  styleTag.setAttribute('type', 'text/css');
+  styleTag.textContent = styles;
+  document.head.appendChild(styleTag);
+  return styleTag;
+};
+var injectRuleSet = function injectRuleSet(selector, declarations) {
+  return injectStyleSheet("\n".concat(selector, " {\n  ").concat(Object.entries(declarations).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      property = _ref2[0],
+      value = _ref2[1];
+    return "".concat(property, ": ").concat(value, ";");
+  }).join("\n  "), "\n}"));
+};
+
+export { injectRuleSet, injectStyleSheet };

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

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

package/components/global/listeners.d.ts

@@ -0,0 +1,8 @@
+export 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

@@ -0,0 +1,58 @@
+import { d as _createClass, l as _toConsumableArray, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.set.js';
+
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
+    _defineProperty(this, "_all", new Map());
+  }
+  _createClass(Listeners, [{
+    key: "trigger",
+    value: function trigger() {
+      for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref[_key] = arguments[_key];
+      }
+      var event = _ref[0],
+        data = _ref[1];
+      var handlers = this._all.get(event);
+      if (handlers) {
+        return Promise.all(_toConsumableArray(handlers).map(function (fn) {
+          return fn(data);
+        }));
+      }
+      return Promise.resolve([]);
+    }
+  }, {
+    key: "add",
+    value: function add(event, handler) {
+      var handlers = this._all.get(event);
+      if (!handlers) {
+        handlers = new Set();
+        this._all.set(event, handlers);
+      }
+      handlers.add(handler);
+    }
+  }, {
+    key: "remove",
+    value: function remove(event, handler) {
+      var handlers = this._all.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+      }
+    }
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      this._all = new Map();
+    }
+  }]);
+  return Listeners;
+}();
+
+export { Listeners as default };

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

@@ -0,0 +1,23 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+
+function memoize(fn) {
+  var primitiveCache = new Map();
+  var objectCache = new WeakMap();
+  return function memoized(arg) {
+    var key = arg !== null && arg !== void 0 ? arg : '__singleValue__';
+    var cache = key instanceof Object ? objectCache : primitiveCache;
+    var cached = cache.get(key);
+    if (cached != null) {
+      return cached;
+    }
+    var value = fn(arg);
+    cache.set(key, value);
+    return value;
+  };
+}
+
+export { memoize as default };

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

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

package/components/global/normalize-indent.js

@@ -0,0 +1,60 @@
+import { l as _toConsumableArray, m as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.slice.js';
+
+function normalizeIndent(string) {
+  var nonemptyRE = /\S/;
+  var indentRE = /^\s*/;
+  var lines = string.split(/\n/g);
+  var linesCopy = _toConsumableArray(lines);
+  //remove empty lines at the beginning and the end
+  var _iterator = _createForOfIteratorHelper(linesCopy),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      if (nonemptyRE.test(line)) {
+        break;
+      } else {
+        lines.shift();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = _createForOfIteratorHelper(linesCopy.reverse()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _line = _step2.value;
+      if (nonemptyRE.test(_line)) {
+        break;
+      } else {
+        lines.pop();
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var indents = lines.filter(function (line) {
+    return nonemptyRE.test(line);
+  }).map(function (line) {
+    var _line$match$0$length, _line$match;
+    return (_line$match$0$length = (_line$match = line.match(indentRE)) === null || _line$match === void 0 ? void 0 : _line$match[0].length) !== null && _line$match$0$length !== void 0 ? _line$match$0$length : 0;
+  });
+  var minIndent = Math.min.apply(Math, _toConsumableArray(indents));
+  return lines.map(function (line) {
+    return line.slice(minIndent);
+  }).join('\n');
+}
+
+export { normalizeIndent as default };

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

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

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

@@ -0,0 +1,19 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+
+// Useful for using fetch with timeout
+// https://github.com/github/fetch/issues/175#issuecomment-284787564
+function promiseWithTimeout(promise, timeout, _ref) {
+  var error = _ref.error,
+    _ref$onTimeout = _ref.onTimeout,
+    onTimeout = _ref$onTimeout === void 0 ? function () {} : _ref$onTimeout;
+  return new Promise(function (resolve, reject) {
+    setTimeout(function () {
+      onTimeout();
+      reject(error || new Error('Timeout'));
+    }, timeout);
+    promise.then(resolve, reject);
+  });
+}
+
+export { promiseWithTimeout as default };

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,9 @@
+import PropTypes from 'prop-types';
+
+var refObject = function refObject(value) {
+  return PropTypes.shape({
+    current: value
+  });
+};
+
+export { refObject };

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

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

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

@@ -0,0 +1,54 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.from.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+
+var Renderer = /*#__PURE__*/function (_Component) {
+  _inherits(Renderer, _Component);
+  var _super = _createSuper(Renderer);
+  function Renderer() {
+    var _this;
+    _classCallCheck(this, Renderer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "nodeRef", function (node) {
+      _this.node = node;
+    });
+    return _this;
+  }
+  _createClass(Renderer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var node = this.node;
+      var nodes = this.props.nodes;
+      if (!node || !nodes || !nodes.length) {
+        return;
+      }
+      Array.from(this.props.nodes).forEach(function (nodeToRender) {
+        return node.appendChild(nodeToRender);
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var className = this.props.className;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        ref: this.nodeRef
+      });
+    }
+  }]);
+  return Renderer;
+}(Component);
+_defineProperty(Renderer, "propTypes", {
+  className: PropTypes.string,
+  nodes: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
+});
+
+export { Renderer as default };

package/components/global/react-render-adapter.d.ts

@@ -0,0 +1 @@
+export declare const setClient: () => void;

package/components/global/react-render-adapter.js

@@ -0,0 +1,6 @@
+import deprecate from 'util-deprecate';
+
+// TODO remove in 7.0
+var setClient = deprecate(function () {}, 'setClient does nothing in Ring UI 6.0 and will be removed in 7.0');
+
+export { setClient };

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

@@ -0,0 +1,10 @@
+import React, { 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>;
+}
+export default function rerenderHOC<P extends {}, C extends Component<P, unknown>>(ComposedComponent: {
+    new (props: P): C;
+}): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<C>>;

package/components/global/rerender-hoc.js

@@ -0,0 +1,46 @@
+import { a as _inherits, b as _createSuper, c as _classCallCheck, _ as _defineProperty, k as _assertThisInitialized, d as _createClass, f as _extends, g as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { forwardRef, Component } from 'react';
+import composeRefs from './composeRefs.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+function rerenderHOC(ComposedComponent) {
+  var Rerenderer = /*#__PURE__*/function (_Component) {
+    _inherits(Rerenderer, _Component);
+    var _super = _createSuper(Rerenderer);
+    function Rerenderer() {
+      var _this;
+      _classCallCheck(this, Rerenderer);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", _this.props.props);
+      return _this;
+    }
+    _createClass(Rerenderer, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var _ref = composeRefs(this.props.forwardedRef);
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, this.state, {
+          ref: function ref(instance) {
+            return _ref(instance != null ? _objectSpread2(_objectSpread2({}, instance), {}, {
+              rerender: _this2.setState.bind(_this2)
+            }) : null);
+          }
+        }));
+      }
+    }]);
+    return Rerenderer;
+  }(Component);
+  return /*#__PURE__*/forwardRef(function RerendererForwardRef(props, ref) {
+    return /*#__PURE__*/React.createElement(Rerenderer, {
+      props: props,
+      forwardedRef: ref
+    });
+  });
+}
+
+export { rerenderHOC as default };

package/components/global/schedule-raf.d.ts

@@ -0,0 +1 @@
+export default function scheduleRAF(trailingCall?: boolean): (cb: () => void) => void;

package/components/global/schedule-raf.js

@@ -0,0 +1,28 @@
+function scheduleRAF(trailingCall) {
+  var scheduledCb;
+  var RAF;
+  var trailingCallScheduled = false;
+  function doSchedule() {
+    RAF = window.requestAnimationFrame(function () {
+      var _scheduledCb;
+      (_scheduledCb = scheduledCb) === null || _scheduledCb === void 0 || _scheduledCb();
+      if (trailingCallScheduled) {
+        trailingCallScheduled = false;
+        doSchedule();
+      } else {
+        RAF = null;
+        scheduledCb = null;
+      }
+    });
+  }
+  return function schedule(cb) {
+    scheduledCb = cb;
+    if (!RAF) {
+      doSchedule();
+    } else if (trailingCall) {
+      trailingCallScheduled = true;
+    }
+  };
+}
+
+export { scheduleRAF as default };

package/components/global/sniffer.d.ts

@@ -0,0 +1,3 @@
+import Sniffr from 'sniffr';
+declare const sniffr: Sniffr;
+export default sniffr;

package/components/global/sniffer.js

@@ -0,0 +1,6 @@
+import Sniffr from 'sniffr';
+
+var sniffr = new Sniffr();
+sniffr.sniff();
+
+export { sniffr as default };

package/components/global/theme.d.ts

@@ -0,0 +1,21 @@
+import React, { HTMLAttributes, ReactElement } from 'react';
+declare enum Theme {
+    AUTO = "auto",
+    LIGHT = "light",
+    DARK = "dark"
+}
+export declare function useTheme(): Theme.LIGHT | Theme.DARK;
+export declare function useThemeClasses(theme: Theme): string;
+export interface WithThemeClassesProps {
+    theme: Theme;
+    children: (classes: string) => ReactElement;
+}
+export declare function WithThemeClasses({ theme, children }: WithThemeClassesProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function applyTheme(theme: Theme.DARK | Theme.LIGHT, container: HTMLElement): void;
+export interface ThemeProviderProps extends HTMLAttributes<HTMLDivElement> {
+    theme?: Theme;
+    passToPopups?: boolean;
+    target?: HTMLElement;
+}
+export declare const ThemeProvider: React.ForwardRefExoticComponent<ThemeProviderProps & React.RefAttributes<HTMLDivElement>>;
+export default Theme;

package/components/global/theme.js

@@ -0,0 +1,42 @@
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react';
+import 'classnames';
+import 'react-dom';
+import '../popup/popup.target.js';
+import '../popup/popup.js';
+export { a as ThemeProvider, W as WithThemeClasses, c as applyTheme, T as default, u as useTheme, b as useThemeClasses } from '../_helpers/theme.js';
+import './get-uid.js';
+import 'prop-types';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import './schedule-raf.js';
+import './dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../shortcuts/shortcuts.js';
+import 'core-js/modules/es.array.map.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import './sniffer.js';
+import 'sniffr';
+import './data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
+import '../popup/popup.consts.js';

package/components/global/trivial-template-tag.d.ts

@@ -0,0 +1 @@
+export default function trivialTemplateTag(f: (string: string) => void): (strings: TemplateStringsArray, ...interpolations: unknown[]) => void;

package/components/global/trivial-template-tag.js

@@ -0,0 +1,21 @@
+import { l as _toConsumableArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.splice.js';
+
+var TWO = 2;
+function trivialTemplateTag(f) {
+  return function (strings) {
+    var chunks = _toConsumableArray(strings);
+    // insert the interpolations where they belong to
+    for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      interpolations[_key - 1] = arguments[_key];
+    }
+    interpolations.forEach(function (value, i) {
+      return chunks.splice(TWO * i + 1, 0, value);
+    });
+    return f(chunks.join(''));
+  };
+}
+
+export { trivialTemplateTag as default };