@codecademy/variance 1.0.0-alpha.f43515.0 → 1.0.0

package/dist/createTheme/createTheme.js

@@ -1,168 +1,136 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
-
-var id = 0;
-
-function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
-
-import { mapValues, merge } from 'lodash';
+import mapValues from 'lodash/mapValues';
+import merge from 'lodash/merge';
 import { flattenScale } from '../utils/flattenScale';
 import { serializeTokens } from '../utils/serializeTokens';
-
-var _theme = _classPrivateFieldLooseKey("theme");
-
-var ThemeBuilder = /*#__PURE__*/function () {
-  function ThemeBuilder(baseTheme) {
-    _classCallCheck(this, ThemeBuilder);
-
-    Object.defineProperty(this, _theme, {
-      writable: true,
-      value: {}
-    });
-    _classPrivateFieldLooseBase(this, _theme)[_theme] = baseTheme;
+class ThemeBuilder {
+  #theme = {};
+  constructor(baseTheme) {
+    this.#theme = baseTheme;
   }
   /**
    *
    * @param key A key of the current theme to transform into CSS Variables and Variable References
    * @example .createScaleVariables('fontSize')
    */
-
-
-  _createClass(ThemeBuilder, [{
-    key: "createScaleVariables",
-    value: function createScaleVariables(key) {
-      var _merge;
-
-      var _serializeTokens = serializeTokens(_classPrivateFieldLooseBase(this, _theme)[_theme][key], key, _classPrivateFieldLooseBase(this, _theme)[_theme]),
-          variables = _serializeTokens.variables,
-          tokens = _serializeTokens.tokens;
-
-      _classPrivateFieldLooseBase(this, _theme)[_theme] = merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], (_merge = {}, _defineProperty(_merge, key, tokens), _defineProperty(_merge, "_variables", {
+  createScaleVariables(key) {
+    const {
+      variables,
+      tokens
+    } = serializeTokens(this.#theme[key], key, this.#theme);
+    this.#theme = merge({}, this.#theme, {
+      [key]: tokens,
+      _variables: {
         root: variables
-      }), _defineProperty(_merge, "_tokens", _defineProperty({}, key, _classPrivateFieldLooseBase(this, _theme)[_theme][key])), _merge));
-      return this;
-    }
-    /**
-     *
-     * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
-     * @example .addColors({ navy: 'navy', hyper: 'purple' })
-     */
-
-  }, {
-    key: "addColors",
-    value: function addColors(colors) {
-      var flatColors = flattenScale(colors);
-
-      var _serializeTokens2 = serializeTokens(flatColors, 'color', _classPrivateFieldLooseBase(this, _theme)[_theme]),
-          variables = _serializeTokens2.variables,
-          tokens = _serializeTokens2.tokens;
-
-      _classPrivateFieldLooseBase(this, _theme)[_theme] = merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], {
-        colors: tokens,
-        _variables: {
-          root: variables
-        },
-        _tokens: {
-          colors: flatColors
-        }
-      });
-      return this;
-    }
-    /**
-     *
-     * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
-     * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
-     * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
-     */
-
-  }, {
-    key: "addColorModes",
-    value: function addColorModes(initialMode, modeConfig) {
-      var _classPrivateFieldLoo,
-          _this = this;
-
-      var modes = mapValues(modeConfig, function (mode) {
-        return flattenScale(mode);
-      });
-
-      var _serializeTokens3 = serializeTokens(mapValues(merge({}, (_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _theme)[_theme].modes) === null || _classPrivateFieldLoo === void 0 ? void 0 : _classPrivateFieldLoo[initialMode], modes[initialMode]), function (color) {
-        return _classPrivateFieldLooseBase(_this, _theme)[_theme].colors[color];
-      }), 'color', _classPrivateFieldLooseBase(this, _theme)[_theme]),
-          colors = _serializeTokens3.tokens,
-          variables = _serializeTokens3.variables;
-
-      var getColorValue = function getColorValue(color) {
-        var _classPrivateFieldLoo2, _classPrivateFieldLoo3;
-
-        return (_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(_this, _theme)[_theme]._tokens) === null || _classPrivateFieldLoo2 === void 0 ? void 0 : (_classPrivateFieldLoo3 = _classPrivateFieldLoo2.colors) === null || _classPrivateFieldLoo3 === void 0 ? void 0 : _classPrivateFieldLoo3[color];
-      };
+      },
+      _tokens: {
+        [key]: this.#theme[key]
+      }
+    });
+    return this;
+  }
 
-      _classPrivateFieldLooseBase(this, _theme)[_theme] = merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], {
-        colors: colors,
-        modes: modes,
-        mode: initialMode,
-        _getColorValue: getColorValue,
-        _variables: {
-          mode: variables
-        },
-        _tokens: {
-          modes: mapValues(modes, function (mode) {
-            return mapValues(mode, getColorValue);
-          })
-        }
-      });
-      return this;
-    }
-    /**
-     *
-     * @param key A new key of theme
-     * @param createScale A function that accepts the current theme and returns a new object of scale values.
-     * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
-     */
+  /**
+   *
+   * @param colors A map of color tokens to add to the theme. These tokens are immediately converted to CSS Variables `--color-${key}`.
+   * @example .addColors({ navy: 'navy', hyper: 'purple' })
+   */
+  addColors(colors) {
+    const flatColors = flattenScale(colors);
+    const {
+      variables,
+      tokens
+    } = serializeTokens(
+    // TS 5.9+ no longer resolves LiteralPaths<> as assignable to SerializedTokensInput; flattened scales are plain token maps at runtime.
+    flatColors, 'color', this.#theme);
+    this.#theme = merge({}, this.#theme, {
+      colors: tokens,
+      _variables: {
+        root: variables
+      },
+      _tokens: {
+        colors: flatColors
+      }
+    });
+    return this;
+  }
 
-  }, {
-    key: "addScale",
-    value: function addScale(key, createScale) {
-      _classPrivateFieldLooseBase(this, _theme)[_theme] = merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], _defineProperty({}, key, flattenScale(createScale(_classPrivateFieldLooseBase(this, _theme)[_theme]))));
-      return this;
-    }
-    /**
-     *
-     * @param key A current key of theme to be updated with new or computed values
-     * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
-     * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
-     */
+  /**
+   *
+   * @param initialMode A key of the object passed for modes.  This sets the default state for the theme and transforms the correct variables.
+   * @param modes A map of color modes with keys of each possible mode with a value of alias to color keys.  This must be called after `addColors`
+   * @example .addColorModes('light', { light: { primary: 'hyper' }, { dark: { primary: 'navy' } } })
+   */
+  addColorModes(initialMode, modeConfig) {
+    const modes = mapValues(modeConfig, mode => flattenScale(mode));
+    const {
+      tokens: colors,
+      variables
+    } = serializeTokens(mapValues(merge({}, this.#theme.modes?.[initialMode], modes[initialMode]), color => this.#theme.colors[color]), 'color', this.#theme);
+    const getColorValue = color => this.#theme._tokens?.colors?.[color];
+    this.#theme = merge({}, this.#theme, {
+      colors,
+      modes,
+      mode: initialMode,
+      _getColorValue: getColorValue,
+      _variables: {
+        mode: variables
+      },
+      _tokens: {
+        modes: mapValues(modes, mode => mapValues(mode, getColorValue))
+      }
+    });
+    return this;
+  }
 
-  }, {
-    key: "updateScale",
-    value: function updateScale(key, updateFn) {
-      _classPrivateFieldLooseBase(this, _theme)[_theme] = merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], _defineProperty({}, key, updateFn(_classPrivateFieldLooseBase(this, _theme)[_theme][key])));
-      return this;
-    }
-    /**
-     * This finalizes the theme build and returns the final theme and variables to be provided.
-     */
+  /**
+   *
+   * @param key A new key of theme
+   * @param createScale A function that accepts the current theme and returns a new object of scale values.
+   * @example .addScale('fonts', () => ({ basic: 'Gotham', cool: 'Wingdings' }))
+   */
+  addScale(key, createScale) {
+    this.#theme = merge({}, this.#theme, {
+      [key]: flattenScale(createScale(this.#theme))
+    });
+    return this;
+  }
 
-  }, {
-    key: "build",
-    value: function build() {
-      return merge({}, _classPrivateFieldLooseBase(this, _theme)[_theme], {
-        _variables: {},
-        _tokens: {}
-      });
-    }
-  }]);
+  /**
+   *
+   * @param key A current key of theme to be updated with new or computed values
+   * @param updateFn A function that accepts an argument of the current values at the specified keys an returns a map of new values to merge.
+   * @example .updateScale('fonts', ({ basic }) => ({ basicFallback: `{basic}, Montserrat` }))
+   */
+  updateScale(key, updateFn) {
+    this.#theme = merge({}, this.#theme, {
+      [key]: updateFn(this.#theme[key])
+    });
+    return this;
+  }
 
-  return ThemeBuilder;
-}();
+  /**
+   *
+   * @param name Adds a name to the theme
+   * This is used for referencing the theme for replacing default fonts.
+   * @example .addName('core')
+   */
+  addName(name) {
+    this.#theme = merge({}, this.#theme, {
+      name
+    });
+    return this;
+  }
 
+  /**
+   * This finalizes the theme build and returns the final theme and variables to be provided.
+   */
+  build() {
+    return merge({}, this.#theme, {
+      _variables: {},
+      _tokens: {}
+    });
+  }
+}
 export function createTheme(base) {
   return new ThemeBuilder(base);
 }

package/dist/createTheme/createTheme.test.js

@@ -1,13 +1,7 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-import { mapValues } from 'lodash';
+import mapValues from 'lodash/mapValues';
 import { createTheme } from './createTheme';
-describe('createTheme', function () {
-  var base = {
+describe('createTheme', () => {
+  const base = {
     breakpoints: {
       xs: '1',
       sm: '2',
@@ -16,53 +10,46 @@ describe('createTheme', function () {
       xl: '5'
     }
   };
-  it('works', function () {
-    expect(createTheme(base).build()).toEqual(_objectSpread(_objectSpread({}, base), {}, {
+  it('works', () => {
+    expect(createTheme(base).build()).toEqual({
+      ...base,
       _variables: {},
       _tokens: {}
-    }));
+    });
   });
-  it('adds a scale', function () {
-    var theme = createTheme(base).addScale('test', function () {
-      return {
-        test: 1,
-        test2: 2
-      };
-    }).build();
+  it('adds a scale', () => {
+    const theme = createTheme(base).addScale('test', () => ({
+      test: 1,
+      test2: 2
+    })).build();
     expect(theme.test).toEqual({
       test: 1,
       test2: 2
     });
   });
-  it('updates a scale', function () {
-    var builder = createTheme(base).addScale('test', function () {
-      return {
-        test: 1,
-        test2: 2
-      };
-    });
+  it('updates a scale', () => {
+    const builder = createTheme(base).addScale('test', () => ({
+      test: 1,
+      test2: 2
+    }));
     expect(builder.build().test).toEqual({
       test: 1,
       test2: 2
     });
-    builder.updateScale('test', function () {
-      return {
-        test3: 3
-      };
-    });
+    builder.updateScale('test', () => ({
+      test3: 3
+    }));
     expect(builder.build().test).toEqual({
       test: 1,
       test2: 2,
       test3: 3
     });
   });
-  it('serializes variables', function () {
-    var theme = createTheme(base).addScale('test', function () {
-      return {
-        test: 1,
-        test2: 2
-      };
-    }).createScaleVariables('test').build();
+  it('serializes variables', () => {
+    const theme = createTheme(base).addScale('test', () => ({
+      test: 1,
+      test2: 2
+    })).createScaleVariables('test').build();
     expect(theme.test).toEqual({
       test: 'var(--test-test)',
       test2: 'var(--test-test2)'
@@ -72,24 +59,22 @@ describe('createTheme', function () {
       '--test-test2': 2
     });
   });
-  describe('colors', function () {
-    var staticColors = {
+  describe('colors', () => {
+    const staticColors = {
       white: 'white',
       black: 'black',
       blue: 'blue',
       green: 'green',
       red: 'red'
     };
-    var cssVariableReferences = mapValues(staticColors, function (val) {
-      return "var(--color-".concat(val, ")");
-    });
-    var builder = createTheme(base);
-    it('creates color variables', function () {
-      var theme = builder.addColors(staticColors).build();
+    const cssVariableReferences = mapValues(staticColors, val => `var(--color-${val})`);
+    const builder = createTheme(base);
+    it('creates color variables', () => {
+      const theme = builder.addColors(staticColors).build();
       expect(theme.colors).toEqual(cssVariableReferences);
     });
-    it('adds colorModes', function () {
-      var theme = builder.addColors(staticColors).addColorModes('light', {
+    it('adds colorModes', () => {
+      const theme = builder.addColors(staticColors).addColorModes('light', {
         light: {
           primary: 'red'
         },
@@ -97,17 +82,16 @@ describe('createTheme', function () {
           primary: 'blue'
         }
       }).build();
-      expect(theme.colors).toEqual(_objectSpread(_objectSpread({}, mapValues(staticColors, function (val) {
-        return "var(--color-".concat(val, ")");
-      })), {}, {
+      expect(theme.colors).toEqual({
+        ...mapValues(staticColors, val => `var(--color-${val})`),
         primary: 'var(--color-primary)'
-      }));
+      });
       expect(theme._variables.mode).toEqual({
         '--color-primary': 'var(--color-red)'
       });
     });
-    it('returns value checker for colors', function () {
-      var theme = builder.addColors({
+    it('returns value checker for colors', () => {
+      const theme = builder.addColors({
         black: '#000000',
         white: '#FFFFFF'
       }).addColorModes('light', {
@@ -121,8 +105,8 @@ describe('createTheme', function () {
       expect(theme._getColorValue('white')).toEqual('#FFFFFF');
       expect(theme._getColorValue(theme.modes.light.primary)).toEqual('#000000');
     });
-    it('returns value checker for colors with deep values', function () {
-      var theme = builder.addColors({
+    it('returns value checker for colors with deep values', () => {
+      const theme = builder.addColors({
         black: '#000000',
         white: '#FFFFFF',
         gray: {
@@ -132,7 +116,7 @@ describe('createTheme', function () {
       }).addColorModes('light', {
         light: {
           primary: {
-            "default": 'gray-200',
+            default: 'gray-200',
             cool: {
               _: 'gray-300',
               town: 'black'
@@ -143,8 +127,8 @@ describe('createTheme', function () {
       expect(theme._getColorValue('gray-300')).toEqual('#666666');
       expect(theme._getColorValue(theme.modes.light['primary-default'])).toEqual('#eeeeee');
     });
-    it('merges color mode configurations when overriden', function () {
-      var theme = builder.addColors({
+    it('merges color mode configurations when overriden', () => {
+      const theme = builder.addColors({
         black: '#000000',
         white: '#FFFFFF'
       }).addColorModes('light', {
@@ -155,7 +139,7 @@ describe('createTheme', function () {
           }
         }
       }).build();
-      var override = createTheme(theme).addColorModes('light', {
+      const override = createTheme(theme).addColorModes('light', {
         light: {
           primary: {
             _: 'white',
@@ -165,8 +149,8 @@ describe('createTheme', function () {
       }).build();
       expect(override.modes.light.primary).toEqual('white');
     });
-    it('returns the raw values of color mode colors on the tokens object', function () {
-      var theme = createTheme(base).addColors({
+    it('returns the raw values of color mode colors on the tokens object', () => {
+      const theme = createTheme(base).addColors({
         black: '#000000',
         gray: {
           300: '#666666'
@@ -188,5 +172,9 @@ describe('createTheme', function () {
         }
       });
     });
+    it('adds a name to the theme', () => {
+      const theme = createTheme(base).addName('scoobyDoo').build();
+      expect(theme.name).toEqual('scoobyDoo');
+    });
   });
 });

package/dist/createTheme/types.d.ts

@@ -9,21 +9,21 @@ import { AbstractTheme } from '../types/theme';
  *
  * The resulting type is then rejoined with keys that cannot be mutated (breakpoints) as the next version of Theme
  */
-export declare type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
+export type MergeTheme<Base extends AbstractTheme, Next, Unmergable = Record<'breakpoints', Base['breakpoints']>> = Unmergable & Merge<Base, Next>;
 /** This merges at 2 levels of depth */
-export declare type Merge<A, B> = {
+export type Merge<A, B> = {
     [K in keyof (A & B)]: K extends keyof B ? K extends keyof A ? AssignValueIfUnmergable<A[K], B[K]> : B[K] : K extends keyof A ? A[K] : never;
 };
 /** Extract mergable objects */
-export declare type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
+export type Mergable<T> = Exclude<T, ((...args: any) => any) | string | boolean | symbol | number | any[]>;
 /** Return B if either A or B is unmergable */
-export declare type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
+export type AssignValueIfUnmergable<A, B> = Mergable<A> extends never ? B : Mergable<B> extends never ? B : Assign<A, B>;
 /** Prefer all values from B */
-export declare type Assign<A, B> = {
+export type Assign<A, B> = {
     [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
 };
 /** These are keys that are consistent for all theme builds - they are loosely typed as they are not meant to be accessed directly */
-export declare type PrivateThemeKeys = {
+export type PrivateThemeKeys = {
     _variables: Record<string, CSSObject>;
     _tokens: Record<string | number, any>;
 };
@@ -39,4 +39,4 @@ export declare type PrivateThemeKeys = {
  *
  * `button-bg-hover`
  * */
-export declare type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;
+export type ColorModeConfig<Colors> = Record<string, Colors | Record<string, Colors> | Record<string, Colors | Record<string, Colors>>>;

package/dist/createTheme/types.js

@@ -0,0 +1 @@
+export {};

package/dist/getPropertyMode/getPropertyMode.d.ts

@@ -0,0 +1,2 @@
+import { PropertyMode } from '../types/properties';
+export declare const getPropertyMode: (useLogicalProperties: boolean) => PropertyMode;

package/dist/getPropertyMode/getPropertyMode.js

@@ -0,0 +1,3 @@
+export const getPropertyMode = useLogicalProperties => {
+  return useLogicalProperties ? 'logical' : 'physical';
+};

package/dist/getPropertyMode/getPropertyMode.test.js

@@ -0,0 +1,15 @@
+import { getPropertyMode } from './getPropertyMode';
+describe('getPropertyMode', () => {
+  it.each([{
+    useLogicalProperties: true,
+    expected: 'logical'
+  }, {
+    useLogicalProperties: false,
+    expected: 'physical'
+  }])('returns "$expected" when useLogicalProperties is $useLogicalProperties', ({
+    useLogicalProperties,
+    expected
+  }) => {
+    expect(getPropertyMode(useLogicalProperties)).toBe(expected);
+  });
+});

package/dist/getPropertyMode/index.d.ts

@@ -0,0 +1 @@
+export * from './getPropertyMode';

package/dist/getPropertyMode/index.js

@@ -0,0 +1 @@
+export * from './getPropertyMode';

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export * from './createTheme';
 export * from './types/props';
 export * from './transforms';
 export * from './scales/createScale';
+export * from './getPropertyMode';

package/dist/index.js

@@ -2,4 +2,5 @@ export { variance } from './core';
 export * from './createTheme';
 export * from './types/props';
 export * from './transforms';
-export * from './scales/createScale';
+export * from './scales/createScale';
+export * from './getPropertyMode';

package/dist/scales/createScale.js

@@ -1,3 +1 @@
-export var createScale = function createScale() {
-  return [];
-};
+export const createScale = () => [];

package/dist/scales/createScaleLookup.d.ts

@@ -1,5 +1,5 @@
 import { Prop } from '../types/config';
 import { ThemeProps } from '../types/props';
-declare type GetScaleValue = (val: string | number, props: ThemeProps) => string | number | undefined;
-export declare const createScaleLookup: (scale: Prop['scale']) => GetScaleValue;
+type GetScaleValue = (val: string | number, props: ThemeProps) => string | number | undefined;
+export declare const createScaleLookup: (scale: Prop["scale"]) => GetScaleValue;
 export {};

package/dist/scales/createScaleLookup.js

@@ -1,24 +1,16 @@
-import { get, isArray, isObject, isString } from 'lodash';
-export var createScaleLookup = function createScaleLookup(scale) {
+import get from 'lodash/get';
+import isArray from 'lodash/isArray';
+import isObject from 'lodash/isObject';
+import isString from 'lodash/isString';
+export const createScaleLookup = scale => {
   if (isString(scale)) {
-    return function (val, props) {
-      return get(props, ['theme', scale, val]);
-    };
+    return (val, props) => get(props, ['theme', scale, val]);
   }
-
   if (isArray(scale)) {
-    return function (val) {
-      return val;
-    };
+    return val => val;
   }
-
   if (isObject(scale)) {
-    return function (val) {
-      return get(scale, val);
-    };
+    return val => get(scale, val);
   }
-
-  return function () {
-    return undefined;
-  };
+  return () => undefined;
 };