improve code and fix build time

packages/overlayscrollbars/dist/overlayscrollbars.esm.js

@@ -477,21 +477,7 @@ const debounce = (functionToDebounce, timeout, maxWait) => {
   };
 };
 
-const cssNumber = {
+const cssNumber = {};
-  animationiterationcount: 1,
-  columncount: 1,
-  fillopacity: 1,
-  flexgrow: 1,
-  flexshrink: 1,
-  fontweight: 1,
-  lineheight: 1,
-  opacity: 1,
-  order: 1,
-  orphans: 1,
-  widows: 1,
-  zindex: 1,
-  zoom: 1,
-};
 
 const parseToZeroOrNumber = (value, toFloat) => {
   const num = toFloat ? parseFloat(value) : parseInt(value, 10);
@@ -682,7 +668,7 @@ const validateOptions = (options, template, optionsDiff, doWriteErrors) => {
   return validateRecursive(options, template, optionsDiff || {}, doWriteErrors || false);
 };
 
-function transformOptions(optionsWithOptionsTemplate) {
+const transformOptions = (optionsWithOptionsTemplate) => {
   const result = {
     _template: {},
     _options: {},
@@ -700,7 +686,7 @@ function transformOptions(optionsWithOptionsTemplate) {
     }
   });
   return result;
-}
+};
 
 const classNameEnvironment = 'os-environment';
 const classNameEnvironmentFlexboxGlue = `${classNameEnvironment}-flexbox-glue`;
@@ -719,9 +705,56 @@ const classNameSizeObserverListenerItem = `${classNameSizeObserverListener}-item
 const classNameSizeObserverListenerItemFinal = `${classNameSizeObserverListenerItem}-final`;
 const classNameTrinsicObserver = 'os-trinsic-observer';
 
+const numberAllowedValues = optionsTemplateTypes.number;
+const stringArrayNullAllowedValues = [optionsTemplateTypes.string, optionsTemplateTypes.array, optionsTemplateTypes.null];
+const booleanTrueTemplate = [true, optionsTemplateTypes.boolean];
+const booleanFalseTemplate = [false, optionsTemplateTypes.boolean];
+const resizeAllowedValues = 'none both horizontal vertical';
+const overflowAllowedValues = 'visible-hidden visible-scroll scroll hidden';
+const scrollbarsVisibilityAllowedValues = 'visible hidden auto';
+const scrollbarsAutoHideAllowedValues = 'never scroll leavemove';
+const defaultOptionsWithTemplate = {
+  resize: ['none', resizeAllowedValues],
+  paddingAbsolute: booleanFalseTemplate,
+  updating: {
+    elementEvents: [[['img', 'load']], [optionsTemplateTypes.array, optionsTemplateTypes.null]],
+    contentMutationDebounce: [80, numberAllowedValues],
+    hostMutationDebounce: [0, numberAllowedValues],
+    resizeDebounce: [0, numberAllowedValues],
+  },
+  overflow: {
+    x: ['scroll', overflowAllowedValues],
+    y: ['scroll', overflowAllowedValues],
+  },
+  scrollbars: {
+    visibility: ['auto', scrollbarsVisibilityAllowedValues],
+    autoHide: ['never', scrollbarsAutoHideAllowedValues],
+    autoHideDelay: [800, numberAllowedValues],
+    dragScroll: booleanTrueTemplate,
+    clickScroll: booleanFalseTemplate,
+    touch: booleanTrueTemplate,
+  },
+  textarea: {
+    dynWidth: booleanFalseTemplate,
+    dynHeight: booleanFalseTemplate,
+    inheritedAttrs: [['style', 'class'], stringArrayNullAllowedValues],
+  },
+  nativeScrollbarsOverlaid: {
+    show: booleanFalseTemplate,
+    initialize: booleanFalseTemplate,
+  },
+};
+const { _template: optionsTemplate, _options: defaultOptions } = transformOptions(defaultOptionsWithTemplate);
+
 let environmentInstance;
 const { abs, round } = Math;
 
+const diffBiggerThanOne = (valOne, valTwo) => {
+  const absValOne = abs(valOne);
+  const absValTwo = abs(valTwo);
+  return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);
+};
+
 const getNativeScrollbarSize = (body, measureElm) => {
   appendChildren(body, measureElm);
   const cSize = clientSize(measureElm);
@@ -768,11 +801,10 @@ const getWindowDPR = () => {
   return window.devicePixelRatio || dDPI / sDPI;
 };
 
-const diffBiggerThanOne = (valOne, valTwo) => {
+const getDefaultInitializationStrategy = (nativeScrollbarStyling) => ({
-  const absValOne = abs(valOne);
+  _padding: !nativeScrollbarStyling,
-  const absValTwo = abs(valTwo);
+  _content: false,
-  return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);
+});
-};
 
 const createEnvironment = () => {
   const { body } = document;
@@ -786,6 +818,9 @@ const createEnvironment = () => {
     x: nativeScrollbarSize.x === 0,
     y: nativeScrollbarSize.y === 0,
   };
+  const defaultInitializationStrategy = getDefaultInitializationStrategy(nativeScrollbarStyling);
+  let initializationStrategy = defaultInitializationStrategy;
+  let defaultDefaultOptions = defaultOptions;
   const env = {
     _autoUpdateLoop: false,
     _nativeScrollbarSize: nativeScrollbarSize,
@@ -802,6 +837,21 @@ const createEnvironment = () => {
     _removeListener(listener) {
       onChangedListener.delete(listener);
     },
+
+    _getInitializationStrategy: () => _extends_1({}, initializationStrategy),
+
+    _setInitializationStrategy(newInitializationStrategy) {
+      initializationStrategy = assignDeep({}, initializationStrategy, newInitializationStrategy);
+    },
+
+    _getDefaultOptions: () => _extends_1({}, defaultDefaultOptions),
+
+    _setDefaultOptions(newDefaultOptions) {
+      defaultDefaultOptions = assignDeep({}, defaultDefaultOptions, newDefaultOptions);
+    },
+
+    _defaultInitializationStrategy: defaultInitializationStrategy,
+    _defaultDefaultOptions: defaultDefaultOptions,
   };
   removeAttr(envElm, 'style');
   removeElements(envElm);
@@ -874,24 +924,36 @@ const createUniqueViewportArrangeElement = () => {
   return elm;
 };
 
+const evaluateCreationFromStrategy = (initializationValue, strategy) => {
+  const isBooleanValue = isBoolean(initializationValue);
+
+  if (isBooleanValue || isUndefined(initializationValue)) {
+    return (isBooleanValue ? initializationValue : strategy) && undefined;
+  }
+
+  return initializationValue;
+};
+
 const createStructureSetup = (target) => {
+  const { _getInitializationStrategy, _nativeScrollbarStyling, _nativeScrollbarIsOverlaid, _cssCustomProperties } = getEnvironment();
+
+  const { _padding: paddingNeeded, _content: contentNeeded } = _getInitializationStrategy();
+
   const targetIsElm = isHTMLElement(target);
   const osTargetObj = targetIsElm
     ? {}
     : {
         _host: target.host,
         _target: target.target,
-        _padding: target.padding,
         _viewport: target.viewport,
-        _content: target.content,
+        _padding: evaluateCreationFromStrategy(target.padding, paddingNeeded),
+        _content: evaluateCreationFromStrategy(target.content, contentNeeded),
       };
 
   if (targetIsElm) {
-    const padding = createDiv(classNamePadding);
     const viewport = createDiv(classNameViewport);
-    const content = createDiv(classNameContent);
+    const padding = paddingNeeded && createDiv(classNamePadding);
-    appendChildren(padding, viewport);
+    const content = contentNeeded && createDiv(classNameContent);
-    appendChildren(viewport, content);
     osTargetObj._target = target;
     osTargetObj._padding = padding;
     osTargetObj._viewport = viewport;
@@ -918,11 +980,14 @@ const createStructureSetup = (target) => {
   }
 
   if (targetIsElm) {
-    appendChildren(_content, getTargetContents(_target));
+    const contentSlot = _content || _viewport;
+    appendChildren(contentSlot, getTargetContents(_target));
     appendChildren(_host, _padding);
+    appendChildren(_padding || _host, _viewport);
+    appendChildren(_viewport, _content);
     push(destroyFns, () => {
-      appendChildren(_host, contents(_content));
+      appendChildren(_host, contents(contentSlot));
-      removeElements(_padding);
+      removeElements(_padding || _viewport);
       removeClass(_host, classNameHost);
     });
   } else {
@@ -979,8 +1044,6 @@ const createStructureSetup = (target) => {
     _host,
   });
 
-  const { _nativeScrollbarStyling, _nativeScrollbarIsOverlaid, _cssCustomProperties } = getEnvironment();
-
   if (_nativeScrollbarStyling) {
     push(destroyFns, removeClass.bind(0, _viewport, classNameViewportScrollbarStyling));
   } else if (!_cssCustomProperties && (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y)) {
@@ -2040,49 +2103,9 @@ const createLifecycleHub = (options, structureSetup) => {
   };
 };
 
-const numberAllowedValues = optionsTemplateTypes.number;
-const stringArrayNullAllowedValues = [optionsTemplateTypes.string, optionsTemplateTypes.array, optionsTemplateTypes.null];
-const booleanTrueTemplate = [true, optionsTemplateTypes.boolean];
-const booleanFalseTemplate = [false, optionsTemplateTypes.boolean];
-const resizeAllowedValues = 'none both horizontal vertical';
-const overflowAllowedValues = 'visible-hidden visible-scroll scroll hidden';
-const scrollbarsVisibilityAllowedValues = 'visible hidden auto';
-const scrollbarsAutoHideAllowedValues = 'never scroll leavemove';
-const defaultOptionsWithTemplate = {
-  resize: ['none', resizeAllowedValues],
-  paddingAbsolute: booleanFalseTemplate,
-  updating: {
-    elementEvents: [[['img', 'load']], [optionsTemplateTypes.array, optionsTemplateTypes.null]],
-    contentMutationDebounce: [80, numberAllowedValues],
-    hostMutationDebounce: [0, numberAllowedValues],
-    resizeDebounce: [0, numberAllowedValues],
-  },
-  overflow: {
-    x: ['scroll', overflowAllowedValues],
-    y: ['scroll', overflowAllowedValues],
-  },
-  scrollbars: {
-    visibility: ['auto', scrollbarsVisibilityAllowedValues],
-    autoHide: ['never', scrollbarsAutoHideAllowedValues],
-    autoHideDelay: [800, numberAllowedValues],
-    dragScroll: booleanTrueTemplate,
-    clickScroll: booleanFalseTemplate,
-    touch: booleanTrueTemplate,
-  },
-  textarea: {
-    dynWidth: booleanFalseTemplate,
-    dynHeight: booleanFalseTemplate,
-    inheritedAttrs: [['style', 'class'], stringArrayNullAllowedValues],
-  },
-  nativeScrollbarsOverlaid: {
-    show: booleanFalseTemplate,
-    initialize: booleanFalseTemplate,
-  },
-};
-const { _template: optionsTemplate, _options: defaultOptions } = transformOptions(defaultOptionsWithTemplate);
-
 const OverlayScrollbars = (target, options, extensions) => {
-  const currentOptions = assignDeep({}, defaultOptions, validateOptions(options || {}, optionsTemplate, null, true)._validated);
+  const { _getDefaultOptions } = getEnvironment();
+  const currentOptions = assignDeep({}, _getDefaultOptions(), validateOptions(options || {}, optionsTemplate, null, true)._validated);
   const structureSetup = createStructureSetup(target);
   const lifecycleHub = createLifecycleHub(currentOptions, structureSetup);
   const instance = {
@@ -2108,9 +2131,5 @@ const OverlayScrollbars = (target, options, extensions) => {
   return instance;
 };
 
-var index = () => {
+export default OverlayScrollbars;
-  return [getEnvironment(), OverlayScrollbars(document.body)];
-};
-
-export default index;
 //# sourceMappingURL=overlayscrollbars.esm.js.map

packages/overlayscrollbars/dist/overlayscrollbars.js

@@ -551,21 +551,7 @@
     };
   };
 
-  var cssNumber = {
+  var cssNumber = {};
-    animationiterationcount: 1,
-    columncount: 1,
-    fillopacity: 1,
-    flexgrow: 1,
-    flexshrink: 1,
-    fontweight: 1,
-    lineheight: 1,
-    opacity: 1,
-    order: 1,
-    orphans: 1,
-    widows: 1,
-    zindex: 1,
-    zoom: 1,
-  };
 
   var parseToZeroOrNumber = function parseToZeroOrNumber(value, toFloat) {
     var num = toFloat ? parseFloat(value) : parseInt(value, 10);
@@ -772,7 +758,7 @@
     return validateRecursive(options, template, optionsDiff || {}, doWriteErrors || false);
   };
 
-  function transformOptions(optionsWithOptionsTemplate) {
+  var transformOptions = function transformOptions(optionsWithOptionsTemplate) {
     var result = {
       _template: {},
       _options: {},
@@ -790,7 +776,7 @@
       }
     });
     return result;
-  }
+  };
 
   var classNameEnvironment = 'os-environment';
   var classNameEnvironmentFlexboxGlue = classNameEnvironment + '-flexbox-glue';
@@ -809,10 +795,60 @@
   var classNameSizeObserverListenerItemFinal = classNameSizeObserverListenerItem + '-final';
   var classNameTrinsicObserver = 'os-trinsic-observer';
 
+  var numberAllowedValues = optionsTemplateTypes.number;
+  var stringArrayNullAllowedValues = [optionsTemplateTypes.string, optionsTemplateTypes.array, optionsTemplateTypes.null];
+  var booleanTrueTemplate = [true, optionsTemplateTypes.boolean];
+  var booleanFalseTemplate = [false, optionsTemplateTypes.boolean];
+  var resizeAllowedValues = 'none both horizontal vertical';
+  var overflowAllowedValues = 'visible-hidden visible-scroll scroll hidden';
+  var scrollbarsVisibilityAllowedValues = 'visible hidden auto';
+  var scrollbarsAutoHideAllowedValues = 'never scroll leavemove';
+  var defaultOptionsWithTemplate = {
+    resize: ['none', resizeAllowedValues],
+    paddingAbsolute: booleanFalseTemplate,
+    updating: {
+      elementEvents: [[['img', 'load']], [optionsTemplateTypes.array, optionsTemplateTypes.null]],
+      contentMutationDebounce: [80, numberAllowedValues],
+      hostMutationDebounce: [0, numberAllowedValues],
+      resizeDebounce: [0, numberAllowedValues],
+    },
+    overflow: {
+      x: ['scroll', overflowAllowedValues],
+      y: ['scroll', overflowAllowedValues],
+    },
+    scrollbars: {
+      visibility: ['auto', scrollbarsVisibilityAllowedValues],
+      autoHide: ['never', scrollbarsAutoHideAllowedValues],
+      autoHideDelay: [800, numberAllowedValues],
+      dragScroll: booleanTrueTemplate,
+      clickScroll: booleanFalseTemplate,
+      touch: booleanTrueTemplate,
+    },
+    textarea: {
+      dynWidth: booleanFalseTemplate,
+      dynHeight: booleanFalseTemplate,
+      inheritedAttrs: [['style', 'class'], stringArrayNullAllowedValues],
+    },
+    nativeScrollbarsOverlaid: {
+      show: booleanFalseTemplate,
+      initialize: booleanFalseTemplate,
+    },
+  };
+
+  var _transformOptions = transformOptions(defaultOptionsWithTemplate),
+    optionsTemplate = _transformOptions._template,
+    defaultOptions = _transformOptions._options;
+
   var environmentInstance;
   var abs = Math.abs,
     round = Math.round;
 
+  var diffBiggerThanOne = function diffBiggerThanOne(valOne, valTwo) {
+    var absValOne = abs(valOne);
+    var absValTwo = abs(valTwo);
+    return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);
+  };
+
   var getNativeScrollbarSize = function getNativeScrollbarSize(body, measureElm) {
     appendChildren(body, measureElm);
     var cSize = clientSize(measureElm);
@@ -859,10 +895,11 @@
     return window.devicePixelRatio || dDPI / sDPI;
   };
 
-  var diffBiggerThanOne = function diffBiggerThanOne(valOne, valTwo) {
+  var getDefaultInitializationStrategy = function getDefaultInitializationStrategy(nativeScrollbarStyling) {
-    var absValOne = abs(valOne);
+    return {
-    var absValTwo = abs(valTwo);
+      _padding: !nativeScrollbarStyling,
-    return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);
+      _content: false,
+    };
   };
 
   var createEnvironment = function createEnvironment() {
@@ -878,6 +915,9 @@
       x: nativeScrollbarSize.x === 0,
       y: nativeScrollbarSize.y === 0,
     };
+    var defaultInitializationStrategy = getDefaultInitializationStrategy(nativeScrollbarStyling);
+    var initializationStrategy = defaultInitializationStrategy;
+    var defaultDefaultOptions = defaultOptions;
     var env = {
       _autoUpdateLoop: false,
       _nativeScrollbarSize: nativeScrollbarSize,
@@ -892,6 +932,20 @@
       _removeListener: function _removeListener(listener) {
         onChangedListener.delete(listener);
       },
+      _getInitializationStrategy: function _getInitializationStrategy() {
+        return _extends_1({}, initializationStrategy);
+      },
+      _setInitializationStrategy: function _setInitializationStrategy(newInitializationStrategy) {
+        initializationStrategy = assignDeep({}, initializationStrategy, newInitializationStrategy);
+      },
+      _getDefaultOptions: function _getDefaultOptions() {
+        return _extends_1({}, defaultDefaultOptions);
+      },
+      _setDefaultOptions: function _setDefaultOptions(newDefaultOptions) {
+        defaultDefaultOptions = assignDeep({}, defaultDefaultOptions, newDefaultOptions);
+      },
+      _defaultInitializationStrategy: defaultInitializationStrategy,
+      _defaultDefaultOptions: defaultDefaultOptions,
     };
     removeAttr(envElm, 'style');
     removeElements(envElm);
@@ -964,24 +1018,42 @@
     return elm;
   };
 
+  var evaluateCreationFromStrategy = function evaluateCreationFromStrategy(initializationValue, strategy) {
+    var isBooleanValue = isBoolean(initializationValue);
+
+    if (isBooleanValue || isUndefined(initializationValue)) {
+      return (isBooleanValue ? initializationValue : strategy) && undefined;
+    }
+
+    return initializationValue;
+  };
+
   var createStructureSetup = function createStructureSetup(target) {
+    var _getEnvironment = getEnvironment(),
+      _getInitializationStrategy = _getEnvironment._getInitializationStrategy,
+      _nativeScrollbarStyling = _getEnvironment._nativeScrollbarStyling,
+      _nativeScrollbarIsOverlaid = _getEnvironment._nativeScrollbarIsOverlaid,
+      _cssCustomProperties = _getEnvironment._cssCustomProperties;
+
+    var _getInitializationStr = _getInitializationStrategy(),
+      paddingNeeded = _getInitializationStr._padding,
+      contentNeeded = _getInitializationStr._content;
+
     var targetIsElm = isHTMLElement(target);
     var osTargetObj = targetIsElm
       ? {}
       : {
           _host: target.host,
           _target: target.target,
-          _padding: target.padding,
           _viewport: target.viewport,
-          _content: target.content,
+          _padding: evaluateCreationFromStrategy(target.padding, paddingNeeded),
+          _content: evaluateCreationFromStrategy(target.content, contentNeeded),
         };
 
     if (targetIsElm) {
-      var padding = createDiv(classNamePadding);
       var viewport = createDiv(classNameViewport);
-      var content = createDiv(classNameContent);
+      var padding = paddingNeeded && createDiv(classNamePadding);
-      appendChildren(padding, viewport);
+      var content = contentNeeded && createDiv(classNameContent);
-      appendChildren(viewport, content);
       osTargetObj._target = target;
       osTargetObj._padding = padding;
       osTargetObj._viewport = viewport;
@@ -1013,11 +1085,14 @@
     }
 
     if (targetIsElm) {
-      appendChildren(_content, getTargetContents(_target));
+      var contentSlot = _content || _viewport;
+      appendChildren(contentSlot, getTargetContents(_target));
       appendChildren(_host, _padding);
+      appendChildren(_padding || _host, _viewport);
+      appendChildren(_viewport, _content);
       push(destroyFns, function () {
-        appendChildren(_host, contents(_content));
+        appendChildren(_host, contents(contentSlot));
-        removeElements(_padding);
+        removeElements(_padding || _viewport);
         removeClass(_host, classNameHost);
       });
     } else {
@@ -1032,8 +1107,10 @@
       appendChildren(_host, _padding);
       appendChildren(_padding || _host, _viewport);
       appendChildren(_viewport, _content);
-      var contentSlot = _content || _viewport;
+
-      appendChildren(contentSlot, targetContents);
+      var _contentSlot = _content || _viewport;
+
+      appendChildren(_contentSlot, targetContents);
       push(destroyFns, function () {
         if (createContent) {
           unwrap(_content);
@@ -1074,11 +1151,6 @@
       _host: _host,
     });
 
-    var _getEnvironment = getEnvironment(),
-      _nativeScrollbarStyling = _getEnvironment._nativeScrollbarStyling,
-      _nativeScrollbarIsOverlaid = _getEnvironment._nativeScrollbarIsOverlaid,
-      _cssCustomProperties = _getEnvironment._cssCustomProperties;
-
     if (_nativeScrollbarStyling) {
       push(destroyFns, removeClass.bind(0, _viewport, classNameViewportScrollbarStyling));
     } else if (!_cssCustomProperties && (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y)) {
@@ -2304,52 +2376,11 @@
     };
   };
 
-  var numberAllowedValues = optionsTemplateTypes.number;
-  var stringArrayNullAllowedValues = [optionsTemplateTypes.string, optionsTemplateTypes.array, optionsTemplateTypes.null];
-  var booleanTrueTemplate = [true, optionsTemplateTypes.boolean];
-  var booleanFalseTemplate = [false, optionsTemplateTypes.boolean];
-  var resizeAllowedValues = 'none both horizontal vertical';
-  var overflowAllowedValues = 'visible-hidden visible-scroll scroll hidden';
-  var scrollbarsVisibilityAllowedValues = 'visible hidden auto';
-  var scrollbarsAutoHideAllowedValues = 'never scroll leavemove';
-  var defaultOptionsWithTemplate = {
-    resize: ['none', resizeAllowedValues],
-    paddingAbsolute: booleanFalseTemplate,
-    updating: {
-      elementEvents: [[['img', 'load']], [optionsTemplateTypes.array, optionsTemplateTypes.null]],
-      contentMutationDebounce: [80, numberAllowedValues],
-      hostMutationDebounce: [0, numberAllowedValues],
-      resizeDebounce: [0, numberAllowedValues],
-    },
-    overflow: {
-      x: ['scroll', overflowAllowedValues],
-      y: ['scroll', overflowAllowedValues],
-    },
-    scrollbars: {
-      visibility: ['auto', scrollbarsVisibilityAllowedValues],
-      autoHide: ['never', scrollbarsAutoHideAllowedValues],
-      autoHideDelay: [800, numberAllowedValues],
-      dragScroll: booleanTrueTemplate,
-      clickScroll: booleanFalseTemplate,
-      touch: booleanTrueTemplate,
-    },
-    textarea: {
-      dynWidth: booleanFalseTemplate,
-      dynHeight: booleanFalseTemplate,
-      inheritedAttrs: [['style', 'class'], stringArrayNullAllowedValues],
-    },
-    nativeScrollbarsOverlaid: {
-      show: booleanFalseTemplate,
-      initialize: booleanFalseTemplate,
-    },
-  };
-
-  var _transformOptions = transformOptions(defaultOptionsWithTemplate),
-    optionsTemplate = _transformOptions._template,
-    defaultOptions = _transformOptions._options;
-
   var OverlayScrollbars = function OverlayScrollbars(target, options, extensions) {
-    var currentOptions = assignDeep({}, defaultOptions, validateOptions(options || {}, optionsTemplate, null, true)._validated);
+    var _getEnvironment = getEnvironment(),
+      _getDefaultOptions = _getEnvironment._getDefaultOptions;
+
+    var currentOptions = assignDeep({}, _getDefaultOptions(), validateOptions(options || {}, optionsTemplate, null, true)._validated);
     var structureSetup = createStructureSetup(target);
     var lifecycleHub = createLifecycleHub(currentOptions, structureSetup);
     var instance = {
@@ -2375,10 +2406,6 @@
     return instance;
   };
 
-  var index = function () {
+  return OverlayScrollbars;
-    return [getEnvironment(), OverlayScrollbars(document.body)];
-  };
-
-  return index;
 });
 //# sourceMappingURL=overlayscrollbars.js.map

packages/overlayscrollbars/src/environment/environment.ts

@@ -17,13 +17,13 @@ import {
   assignDeep,
   PartialOptions,
 } from 'support';
-import { OverlayScrollbarsOptions, defaultOptions } from 'options';
 import {
   classNameEnvironment,
   classNameEnvironmentFlexboxGlue,
   classNameEnvironmentFlexboxGlueMax,
   classNameViewportScrollbarStyling,
 } from 'classnames';
+import { OverlayScrollbarsOptions, defaultOptions } from 'options';
 
 export interface InitializationStrategy {
   _padding: boolean;

packages/overlayscrollbars/src/index.ts

@@ -1,6 +1,3 @@
-import { getEnvironment } from 'environment';
 import { OverlayScrollbars } from 'overlayscrollbars/overlayscrollbars';
 
-export default () => {
+export default OverlayScrollbars;
-  return [getEnvironment(), OverlayScrollbars(document.body)];
-};

packages/overlayscrollbars/src/options/options.ts

@@ -4,7 +4,6 @@ import {
   OptionsTemplateValue,
   OptionsWithOptionsTemplateValue,
   OptionsWithOptionsTemplate,
-  Func,
 } from 'support/options';
 import { ResizeBehavior, OverflowBehavior, VisibilityBehavior, AutoHideBehavior, OverlayScrollbarsOptions } from 'options';
 

packages/overlayscrollbars/src/support/dom/style.ts

@@ -10,19 +10,19 @@ export interface TRBL {
 }
 
 const cssNumber = {
-  animationiterationcount: 1,
+  //animationiterationcount: 1,
-  columncount: 1,
+  //columncount: 1,
-  fillopacity: 1,
+  //fillopacity: 1,
-  flexgrow: 1,
+  //flexgrow: 1,
-  flexshrink: 1,
+  //flexshrink: 1,
-  fontweight: 1,
+  //fontweight: 1,
-  lineheight: 1,
+  //lineheight: 1,
-  opacity: 1,
+  //opacity: 1,
-  order: 1,
+  //order: 1,
-  orphans: 1,
+  //orphans: 1,
-  widows: 1,
+  //widows: 1,
-  zindex: 1,
+  //zindex: 1,
-  zoom: 1,
+  //zoom: 1,
 };
 
 const parseToZeroOrNumber = (value: string, toFloat?: boolean): number => {
@@ -35,7 +35,7 @@ const adaptCSSVal = (prop: string, val: string | number): string | number => (!c
 const getCSSVal = (elm: HTMLElement, computedStyle: CSSStyleDeclaration, prop: string): string =>
   /* istanbul ignore next */
   computedStyle != null ? computedStyle[prop] || computedStyle.getPropertyValue(prop) : elm.style[prop];
-const setCSSVal = (elm: HTMLElement | null | undefined, prop: string, val: string | number): void => {
+const setCSSVal = (elm: HTMLElement | false | null | undefined, prop: string, val: string | number): void => {
   try {
     if (elm) {
       const { style } = elm;
@@ -53,11 +53,11 @@ const setCSSVal = (elm: HTMLElement | null | undefined, prop: string, val: strin
  * @param elm The element to which the styles shall be applied to / be read from.
  * @param styles The styles which shall be set or read.
  */
-export function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: StyleObject<CustomCssProps>): void;
+export function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: StyleObject<CustomCssProps>): void;
-export function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: string): string;
+export function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: string): string;
-export function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: Array<string> | string): { [key: string]: string };
+export function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: Array<string> | string): { [key: string]: string };
 export function style<CustomCssProps>(
-  elm: HTMLElement | null | undefined,
+  elm: HTMLElement | false | null | undefined,
   styles: StyleObject<CustomCssProps> | Array<string> | string
 ): { [key: string]: string } | string | void {
   const getSingleStyle = isString(styles);
@@ -83,7 +83,7 @@ export function style<CustomCssProps>(
  * Hides the passed element (display: none).
  * @param elm The element which shall be hidden.
  */
-export const hide = (elm: HTMLElement | null): void => {
+export const hide = (elm: HTMLElement | false | null | undefined): void => {
   style(elm, { display: 'none' });
 };
 
@@ -91,7 +91,7 @@ export const hide = (elm: HTMLElement | null): void => {
  * Shows the passed element (display: block).
  * @param elm The element which shall be shown.
  */
-export const show = (elm: HTMLElement | null | undefined): void => {
+export const show = (elm: HTMLElement | false | null | undefined): void => {
   style(elm, { display: 'block' });
 };
 
@@ -100,7 +100,7 @@ export const show = (elm: HTMLElement | null | undefined): void => {
  * @param elm
  * @param property
  */
-export const topRightBottomLeft = (elm: HTMLElement | null | undefined, propertyPrefix?: string, propertySuffix?: string): TRBL => {
+export const topRightBottomLeft = (elm: HTMLElement | false | null | undefined, propertyPrefix?: string, propertySuffix?: string): TRBL => {
   const finalPrefix = propertyPrefix ? `${propertyPrefix}-` : '';
   const finalSuffix = propertySuffix ? `-${propertySuffix}` : '';
   const top = `${finalPrefix}top${finalSuffix}`;

packages/overlayscrollbars/src/support/options/index.ts

@@ -1,51 +1,2 @@
-import { PlainObject } from 'typings';
-
 export * from 'support/options/validation';
 export * from 'support/options/transformation';
-
-type ObjectType = Record<string, unknown>;
-
-export type Func = (this: any, ...args: any[]) => any;
-export type OptionsTemplateType<T extends OptionsTemplateNativeTypes> = ExtractPropsKey<OptionsTemplateTypeMap, T>;
-export type OptionsTemplateTypes = keyof OptionsTemplateTypeMap;
-export type OptionsTemplateNativeTypes = OptionsTemplateTypeMap[keyof OptionsTemplateTypeMap];
-export type OptionsTemplateValue<T extends OptionsTemplateNativeTypes = string> = T extends string
-  ? string extends T
-    ? OptionsTemplateValueNonEnum<T>
-    : string
-  : OptionsTemplateValueNonEnum<T>;
-export type OptionsTemplate<T> = {
-  [P in keyof T]: T[P] extends ObjectType ? OptionsTemplate<T[P]> : T[P] extends OptionsTemplateNativeTypes ? OptionsTemplateValue<T[P]> : never;
-};
-export type OptionsValidationResult<T> = {
-  readonly _foreign: PlainObject;
-  readonly _validated: PartialOptions<T>;
-};
-// Options With Options Template Typings:
-export type OptionsWithOptionsTemplateValue<T extends OptionsTemplateNativeTypes> = [T, OptionsTemplateValue<T>];
-export type OptionsWithOptionsTemplate<T extends Required<T>> = {
-  [P in keyof T]: T[P] extends ObjectType
-    ? OptionsWithOptionsTemplate<Required<T[P]>>
-    : T[P] extends OptionsTemplateNativeTypes
-    ? OptionsWithOptionsTemplateValue<T[P]>
-    : never;
-};
-export type PartialOptions<T> = {
-  [P in keyof T]?: T[P] extends ObjectType ? PartialOptions<T[P]> : T[P];
-};
-
-type OptionsTemplateTypeMap = {
-  __TPL_boolean_TYPE__: boolean;
-  __TPL_number_TYPE__: number;
-  __TPL_string_TYPE__: string;
-  __TPL_array_TYPE__: Array<any> | ReadonlyArray<any>;
-  __TPL_function_TYPE__: Func;
-  __TPL_null_TYPE__: null;
-  __TPL_object_TYPE__: Record<string, unknown>;
-};
-type OptionsTemplateValueNonEnum<T extends OptionsTemplateNativeTypes> =
-  | OptionsTemplateType<T>
-  | [OptionsTemplateType<T>, ...Array<OptionsTemplateTypes>];
-type ExtractPropsKey<T, TProps extends T[keyof T]> = {
-  [P in keyof T]: TProps extends T[P] ? P : never;
-}[keyof T];

packages/overlayscrollbars/src/support/options/transformation.ts

@@ -1,21 +1,35 @@
-import { OptionsTemplate, OptionsWithOptionsTemplate, OptionsTemplateTypes } from 'support/options';
+import {
+  OptionsTemplate,
+  OptionsObjectType,
+  OptionsTemplateNativeTypes,
+  OptionsTemplateTypes,
+  OptionsTemplateValue,
+} from 'support/options/validation';
 import { PlainObject } from 'typings';
 import { isArray } from 'support/utils/types';
 import { each, keys } from 'support/utils';
 
-export interface OptionsWithOptionsTemplateTransformation<T extends Required<T>> {
+export interface OptionsWithOptionsTemplateTransformation<T> {
   _template: OptionsTemplate<T>;
   _options: T;
 }
 
+export type OptionsWithOptionsTemplateValue<T extends OptionsTemplateNativeTypes> = [T, OptionsTemplateValue<T>];
+
+export type OptionsWithOptionsTemplate<T> = {
+  [P in keyof T]: T[P] extends OptionsObjectType
+    ? OptionsWithOptionsTemplate<T[P]>
+    : T[P] extends OptionsTemplateNativeTypes
+    ? OptionsWithOptionsTemplateValue<T[P]>
+    : never;
+};
+
 /**
  * Transforms the given OptionsWithOptionsTemplate<T> object to its corresponding generic (T) Object or its corresponding Template object.
  * @param optionsWithOptionsTemplate The OptionsWithOptionsTemplate<T> object which shall be converted.
  * @param toTemplate True if the given OptionsWithOptionsTemplate<T> shall be converted to its corresponding Template object.
  */
-export function transformOptions<T extends Required<T>>(
+export const transformOptions = <T>(optionsWithOptionsTemplate: OptionsWithOptionsTemplate<T>): OptionsWithOptionsTemplateTransformation<T> => {
-  optionsWithOptionsTemplate: OptionsWithOptionsTemplate<T>
-): OptionsWithOptionsTemplateTransformation<T> {
   const result: any = {
     _template: {},
     _options: {},
@@ -36,4 +50,4 @@ export function transformOptions<T extends Required<T>>(
   });
 
   return result;
-}
+};

packages/overlayscrollbars/src/support/options/validation.ts

@@ -1,14 +1,71 @@
 import { each, hasOwnProperty, keys, push, isEmptyObject } from 'support/utils';
 import { type, isArray, isUndefined, isPlainObject, isString } from 'support/utils/types';
-import { OptionsTemplate, OptionsTemplateTypes, OptionsTemplateType, PartialOptions, Func, OptionsValidationResult } from 'support/options';
 import { PlainObject } from 'typings';
 
+export type OptionsObjectType = Record<string, unknown>;
+export type OptionsFunctionType = (this: unknown, ...args: unknown[]) => unknown;
+export type OptionsTemplateType<T extends OptionsTemplateNativeTypes> = ExtractPropsKey<OptionsTemplateTypeMap, T>;
+export type OptionsTemplateTypes = keyof OptionsTemplateTypeMap;
+export type OptionsTemplateNativeTypes = OptionsTemplateTypeMap[keyof OptionsTemplateTypeMap];
+
+export type OptionsTemplateValue<T extends OptionsTemplateNativeTypes = string> = T extends string
+  ? string extends T
+    ? OptionsTemplateValueNonEnum<T>
+    : string
+  : OptionsTemplateValueNonEnum<T>;
+
+export type OptionsTemplate<T> = {
+  [P in keyof T]: T[P] extends OptionsObjectType
+    ? OptionsTemplate<T[P]>
+    : T[P] extends OptionsTemplateNativeTypes
+    ? OptionsTemplateValue<T[P]>
+    : never;
+};
+
+export type OptionsValidationResult<T> = {
+  readonly _foreign: Record<string, unknown>;
+  readonly _validated: PartialOptions<T>;
+};
+
+export type PartialOptions<T> = {
+  [P in keyof T]?: T[P] extends OptionsObjectType ? PartialOptions<T[P]> : T[P];
+};
+
+type OptionsTemplateTypeMap = {
+  __TPL_boolean_TYPE__: boolean;
+  __TPL_number_TYPE__: number;
+  __TPL_string_TYPE__: string;
+  __TPL_array_TYPE__: Array<any> | ReadonlyArray<any>;
+  __TPL_function_TYPE__: OptionsFunctionType;
+  __TPL_null_TYPE__: null;
+  __TPL_object_TYPE__: OptionsObjectType;
+};
+
+type OptionsTemplateValueNonEnum<T extends OptionsTemplateNativeTypes> =
+  | OptionsTemplateType<T>
+  | [OptionsTemplateType<T>, ...Array<OptionsTemplateTypes>];
+
+type ExtractPropsKey<T, TProps extends T[keyof T]> = {
+  [P in keyof T]: TProps extends T[P] ? P : never;
+}[keyof T];
+
+type OptionsTemplateTypesDictionary = {
+  readonly boolean: OptionsTemplateType<boolean>;
+  readonly number: OptionsTemplateType<number>;
+  readonly string: OptionsTemplateType<string>;
+  readonly array: OptionsTemplateType<Array<any>>;
+  readonly object: OptionsTemplateType<OptionsObjectType>;
+  readonly function: OptionsTemplateType<OptionsFunctionType>;
+  readonly null: OptionsTemplateType<null>;
+};
+
 const { stringify } = JSON;
 
 /**
  * A prefix and suffix tuple which serves as recognition pattern for template types.
  */
 const templateTypePrefixSuffix: readonly [string, string] = ['__TPL_', '_TYPE__'];
+
 /**
  * A object which serves as a mapping for "normal" types and template types.
  * Key   = normal type string
@@ -165,13 +222,3 @@ const validateOptions = <T extends PlainObject>(
 };
 
 export { validateOptions, optionsTemplateTypes };
-
-type OptionsTemplateTypesDictionary = {
-  readonly boolean: OptionsTemplateType<boolean>;
-  readonly number: OptionsTemplateType<number>;
-  readonly string: OptionsTemplateType<string>;
-  readonly array: OptionsTemplateType<Array<any>>;
-  readonly object: OptionsTemplateType<Record<string, unknown>>;
-  readonly function: OptionsTemplateType<Func>;
-  readonly null: OptionsTemplateType<null>;
-};

packages/overlayscrollbars/types/environment/environment.d.ts

@@ -1,4 +1,9 @@
-import { XY } from 'support';
+import { XY, PartialOptions } from 'support';
+import { OverlayScrollbarsOptions } from 'options';
+export interface InitializationStrategy {
+    _padding: boolean;
+    _content: boolean;
+}
 export declare type OnEnvironmentChanged = (env: Environment) => void;
 export interface Environment {
     _autoUpdateLoop: boolean;
@@ -13,5 +18,11 @@ export interface Environment {
     _cssCustomProperties: boolean;
     _addListener(listener: OnEnvironmentChanged): void;
     _removeListener(listener: OnEnvironmentChanged): void;
+    _getInitializationStrategy(): InitializationStrategy;
+    _setInitializationStrategy(newInitializationStrategy: Partial<InitializationStrategy>): void;
+    _getDefaultOptions(): OverlayScrollbarsOptions;
+    _setDefaultOptions(newDefaultOptions: PartialOptions<OverlayScrollbarsOptions>): void;
+    _defaultInitializationStrategy: InitializationStrategy;
+    _defaultDefaultOptions: OverlayScrollbarsOptions;
 }
 export declare const getEnvironment: () => Environment;

packages/overlayscrollbars/types/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => any[];
+import { OverlayScrollbars } from 'overlayscrollbars/overlayscrollbars';
-export default _default;
+export default OverlayScrollbars;

packages/overlayscrollbars/types/lifecycles/lifecycleHub.d.ts

@@ -1,4 +1,4 @@
-import { XY, TRBL, CacheValues } from 'support';
+import { XY, TRBL, CacheValues, PartialOptions } from 'support';
 import { OverlayScrollbarsOptions } from 'options';
 import { StructureSetup } from 'setups/structureSetup';
 import { StyleObject } from 'typings';
@@ -23,7 +23,7 @@ export interface LifecycleUpdateHints extends LifecycleAdaptiveUpdateHints {
 }
 export declare type Lifecycle = (updateHints: LifecycleUpdateHints, checkOption: LifecycleCheckOption, force: boolean) => Partial<LifecycleAdaptiveUpdateHints> | void;
 export interface LifecycleHubInstance {
-    _update(changedOptions?: Partial<OverlayScrollbarsOptions> | null, force?: boolean): void;
+    _update(changedOptions?: PartialOptions<OverlayScrollbarsOptions> | null, force?: boolean): void;
     _destroy(): void;
 }
 export interface LifecycleHub {

packages/overlayscrollbars/types/options/index.d.ts

@@ -11,35 +11,35 @@ export declare type OverflowAmountChangedCallback = (this: any, args?: OverflowA
 export declare type DirectionChangedCallback = (this: any, args?: DirectionChangedArgs) => void;
 export declare type SizeChangedCallback = (this: any, args?: SizeChangedArgs) => void;
 export declare type UpdatedCallback = (this: any, args?: UpdatedArgs) => void;
-export interface Options {
+export interface OverlayScrollbarsOptions {
-    resize?: ResizeBehavior;
+    resize: ResizeBehavior;
-    paddingAbsolute?: boolean;
+    paddingAbsolute: boolean;
-    updating?: {
+    updating: {
-        elementEvents?: ReadonlyArray<[string, string]> | null;
+        elementEvents: ReadonlyArray<[string, string]> | null;
-        contentMutationDebounce?: number;
+        contentMutationDebounce: number;
-        hostMutationDebounce?: number;
+        hostMutationDebounce: number;
-        resizeDebounce?: number;
+        resizeDebounce: number;
     };
-    overflow?: {
+    overflow: {
-        x?: OverflowBehavior;
+        x: OverflowBehavior;
-        y?: OverflowBehavior;
+        y: OverflowBehavior;
     };
-    scrollbars?: {
+    scrollbars: {
-        visibility?: VisibilityBehavior;
+        visibility: VisibilityBehavior;
-        autoHide?: AutoHideBehavior;
+        autoHide: AutoHideBehavior;
-        autoHideDelay?: number;
+        autoHideDelay: number;
-        dragScroll?: boolean;
+        dragScroll: boolean;
-        clickScroll?: boolean;
+        clickScroll: boolean;
-        touch?: boolean;
+        touch: boolean;
     };
-    textarea?: {
+    textarea: {
-        dynWidth?: boolean;
+        dynWidth: boolean;
-        dynHeight?: boolean;
+        dynHeight: boolean;
-        inheritedAttrs?: string | ReadonlyArray<string> | null;
+        inheritedAttrs: string | ReadonlyArray<string> | null;
     };
-    nativeScrollbarsOverlaid?: {
+    nativeScrollbarsOverlaid: {
-        show?: boolean;
+        show: boolean;
-        initialize?: boolean;
+        initialize: boolean;
     };
 }
 export interface OverflowChangedArgs {

packages/overlayscrollbars/types/options/options.d.ts

@@ -1,2 +1,2 @@
 import { OverlayScrollbarsOptions } from 'options';
-export declare const optionsTemplate: import("../support/options").OptionsTemplate<Required<OverlayScrollbarsOptions>>, defaultOptions: Required<OverlayScrollbarsOptions>;
+export declare const optionsTemplate: import("../support/options").OptionsTemplate<OverlayScrollbarsOptions>, defaultOptions: OverlayScrollbarsOptions;

packages/overlayscrollbars/types/overlayscrollbars/OverlayScrollbars.d.ts

@@ -1,4 +1,5 @@
 import { OSTarget, OSTargetObject } from 'typings';
+import { PartialOptions } from 'support';
 import { OverlayScrollbarsOptions } from 'options';
-declare const OverlayScrollbars: (target: OSTarget | OSTargetObject, options?: OverlayScrollbarsOptions | undefined, extensions?: any) => any;
+declare const OverlayScrollbars: (target: OSTarget | OSTargetObject, options?: PartialOptions<OverlayScrollbarsOptions> | undefined, extensions?: any) => any;
 export { OverlayScrollbars };

packages/overlayscrollbars/types/setups/structureSetup.d.ts

@@ -1,4 +1,4 @@
-import { OSTarget, OSTargetObject, InternalVersionOf } from 'typings';
+import { OSTarget, OSTargetObject, OSTargetElement } from 'typings';
 export interface OSTargetContext {
     _isTextarea: boolean;
     _isBody: boolean;
@@ -7,9 +7,13 @@ export interface OSTargetContext {
     _windowElm: Window;
     _documentElm: HTMLDocument;
 }
-export interface PreparedOSTargetObject extends Required<InternalVersionOf<OSTargetObject>> {
+export interface PreparedOSTargetObject {
+    _target: OSTargetElement;
     _host: HTMLElement;
-    _viewportArrange: HTMLStyleElement | null;
+    _viewport: HTMLElement;
+    _padding: HTMLElement | false | null;
+    _content: HTMLElement | false | null;
+    _viewportArrange: HTMLStyleElement | false | null;
 }
 export interface StructureSetup {
     _targetObj: PreparedOSTargetObject;

packages/overlayscrollbars/types/support/dom/class.d.ts

@@ -3,19 +3,19 @@
  * @param elm The element.
  * @param className The class name(s).
  */
-export declare const hasClass: (elm: Element | null | undefined, className: string) => boolean;
+export declare const hasClass: (elm: Element | false | null | undefined, className: string) => boolean;
 /**
  * Adds the given class name(s) to the given element.
  * @param elm The element.
  * @param className The class name(s) which shall be added. (separated by spaces)
  */
-export declare const addClass: (elm: Element | null | undefined, className: string) => void;
+export declare const addClass: (elm: Element | false | null | undefined, className: string) => void;
 /**
  * Removes the given class name(s) from the given element.
  * @param elm The element.
  * @param className The class name(s) which shall be removed. (separated by spaces)
  */
-export declare const removeClass: (elm: Element | null | undefined, className: string) => void;
+export declare const removeClass: (elm: Element | false | null | undefined, className: string) => void;
 /**
  * Takes two className strings, compares them and returns the difference as array.
  * @param classNameA ClassName A.

packages/overlayscrollbars/types/support/dom/manipulation.d.ts

@@ -1,4 +1,4 @@
-declare type NodeCollection = ArrayLike<Node> | Node | null | undefined;
+declare type NodeCollection = ArrayLike<Node> | Node | false | null | undefined;
 /**
  * Appends the given children at the end of the given Node.
  * @param node The Node to which the children shall be appended.

packages/overlayscrollbars/types/support/dom/style.d.ts

@@ -10,24 +10,24 @@ export interface TRBL {
  * @param elm The element to which the styles shall be applied to / be read from.
  * @param styles The styles which shall be set or read.
  */
-export declare function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: StyleObject<CustomCssProps>): void;
+export declare function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: StyleObject<CustomCssProps>): void;
-export declare function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: string): string;
+export declare function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: string): string;
-export declare function style<CustomCssProps>(elm: HTMLElement | null | undefined, styles: Array<string> | string): {
+export declare function style<CustomCssProps>(elm: HTMLElement | false | null | undefined, styles: Array<string> | string): {
     [key: string]: string;
 };
 /**
  * Hides the passed element (display: none).
  * @param elm The element which shall be hidden.
  */
-export declare const hide: (elm: HTMLElement | null) => void;
+export declare const hide: (elm: HTMLElement | false | null | undefined) => void;
 /**
  * Shows the passed element (display: block).
  * @param elm The element which shall be shown.
  */
-export declare const show: (elm: HTMLElement | null | undefined) => void;
+export declare const show: (elm: HTMLElement | false | null | undefined) => void;
 /**
  * Returns a top
  * @param elm
  * @param property
  */
-export declare const topRightBottomLeft: (elm: HTMLElement | null | undefined, propertyPrefix?: string | undefined, propertySuffix?: string | undefined) => TRBL;
+export declare const topRightBottomLeft: (elm: HTMLElement | false | null | undefined, propertyPrefix?: string | undefined, propertySuffix?: string | undefined) => TRBL;

packages/overlayscrollbars/types/support/dom/traversal.d.ts

@@ -1,4 +1,4 @@
-declare type InputElementType = Element | Node | null | undefined;
+declare type InputElementType = Element | Node | false | null | undefined;
 declare type OutputElementType = Element | null;
 /**
  * Find all elements with the passed selector, outgoing (and including) the passed element or the document if no element was provided.

packages/overlayscrollbars/types/support/options/index.d.ts

@@ -1,35 +1,2 @@
-import { PlainObject } from 'typings';
 export * from 'support/options/validation';
 export * from 'support/options/transformation';
-export declare type Func = (this: any, ...args: any[]) => any;
-export declare type OptionsTemplateType<T extends OptionsTemplateNativeTypes> = ExtractPropsKey<OptionsTemplateTypeMap, T>;
-export declare type OptionsTemplateTypes = keyof OptionsTemplateTypeMap;
-export declare type OptionsTemplateNativeTypes = OptionsTemplateTypeMap[keyof OptionsTemplateTypeMap];
-export declare type OptionsTemplateValue<T extends OptionsTemplateNativeTypes = string> = T extends string ? string extends T ? OptionsTemplateValueNonEnum<T> : string : OptionsTemplateValueNonEnum<T>;
-export declare type OptionsTemplate<T extends Required<T>> = {
-    [P in keyof T]: PlainObject extends T[P] ? OptionsTemplate<Required<T[P]>> : T[P] extends OptionsTemplateNativeTypes ? OptionsTemplateValue<T[P]> : never;
-};
-export declare type OptionsValidated<T> = {
-    [P in keyof T]?: T[P];
-};
-export declare type OptionsValidationResult<T> = {
-    readonly _foreign: PlainObject;
-    readonly _validated: OptionsValidated<T>;
-};
-export declare type OptionsWithOptionsTemplateValue<T extends OptionsTemplateNativeTypes> = [T, OptionsTemplateValue<T>];
-export declare type OptionsWithOptionsTemplate<T extends Required<T>> = {
-    [P in keyof T]: PlainObject extends T[P] ? OptionsWithOptionsTemplate<Required<T[P]>> : T[P] extends OptionsTemplateNativeTypes ? OptionsWithOptionsTemplateValue<T[P]> : never;
-};
-declare type OptionsTemplateTypeMap = {
-    __TPL_boolean_TYPE__: boolean;
-    __TPL_number_TYPE__: number;
-    __TPL_string_TYPE__: string;
-    __TPL_array_TYPE__: Array<any> | ReadonlyArray<any>;
-    __TPL_function_TYPE__: Func;
-    __TPL_null_TYPE__: null;
-    __TPL_object_TYPE__: Record<string, unknown>;
-};
-declare type OptionsTemplateValueNonEnum<T extends OptionsTemplateNativeTypes> = OptionsTemplateType<T> | [OptionsTemplateType<T>, ...Array<OptionsTemplateTypes>];
-declare type ExtractPropsKey<T, TProps extends T[keyof T]> = {
-    [P in keyof T]: TProps extends T[P] ? P : never;
-}[keyof T];

packages/overlayscrollbars/types/support/options/transformation.d.ts

@@ -1,11 +1,15 @@
-import { OptionsTemplate, OptionsWithOptionsTemplate } from 'support/options';
+import { OptionsTemplate, OptionsObjectType, OptionsTemplateNativeTypes, OptionsTemplateValue } from 'support/options/validation';
-export interface OptionsWithOptionsTemplateTransformation<T extends Required<T>> {
+export interface OptionsWithOptionsTemplateTransformation<T> {
     _template: OptionsTemplate<T>;
     _options: T;
 }
+export declare type OptionsWithOptionsTemplateValue<T extends OptionsTemplateNativeTypes> = [T, OptionsTemplateValue<T>];
+export declare type OptionsWithOptionsTemplate<T> = {
+    [P in keyof T]: T[P] extends OptionsObjectType ? OptionsWithOptionsTemplate<T[P]> : T[P] extends OptionsTemplateNativeTypes ? OptionsWithOptionsTemplateValue<T[P]> : never;
+};
 /**
  * Transforms the given OptionsWithOptionsTemplate<T> object to its corresponding generic (T) Object or its corresponding Template object.
  * @param optionsWithOptionsTemplate The OptionsWithOptionsTemplate<T> object which shall be converted.
  * @param toTemplate True if the given OptionsWithOptionsTemplate<T> shall be converted to its corresponding Template object.
  */
-export declare function transformOptions<T extends Required<T>>(optionsWithOptionsTemplate: OptionsWithOptionsTemplate<T>): OptionsWithOptionsTemplateTransformation<T>;
+export declare const transformOptions: <T>(optionsWithOptionsTemplate: OptionsWithOptionsTemplate<T>) => OptionsWithOptionsTemplateTransformation<T>;

packages/overlayscrollbars/types/support/options/validation.d.ts

@@ -1,5 +1,42 @@
-import { OptionsTemplate, OptionsTemplateType, Func, OptionsValidationResult } from 'support/options';
 import { PlainObject } from 'typings';
+export declare type OptionsObjectType = Record<string, unknown>;
+export declare type OptionsFunctionType = (this: unknown, ...args: unknown[]) => unknown;
+export declare type OptionsTemplateType<T extends OptionsTemplateNativeTypes> = ExtractPropsKey<OptionsTemplateTypeMap, T>;
+export declare type OptionsTemplateTypes = keyof OptionsTemplateTypeMap;
+export declare type OptionsTemplateNativeTypes = OptionsTemplateTypeMap[keyof OptionsTemplateTypeMap];
+export declare type OptionsTemplateValue<T extends OptionsTemplateNativeTypes = string> = T extends string ? string extends T ? OptionsTemplateValueNonEnum<T> : string : OptionsTemplateValueNonEnum<T>;
+export declare type OptionsTemplate<T> = {
+    [P in keyof T]: T[P] extends OptionsObjectType ? OptionsTemplate<T[P]> : T[P] extends OptionsTemplateNativeTypes ? OptionsTemplateValue<T[P]> : never;
+};
+export declare type OptionsValidationResult<T> = {
+    readonly _foreign: Record<string, unknown>;
+    readonly _validated: PartialOptions<T>;
+};
+export declare type PartialOptions<T> = {
+    [P in keyof T]?: T[P] extends OptionsObjectType ? PartialOptions<T[P]> : T[P];
+};
+declare type OptionsTemplateTypeMap = {
+    __TPL_boolean_TYPE__: boolean;
+    __TPL_number_TYPE__: number;
+    __TPL_string_TYPE__: string;
+    __TPL_array_TYPE__: Array<any> | ReadonlyArray<any>;
+    __TPL_function_TYPE__: OptionsFunctionType;
+    __TPL_null_TYPE__: null;
+    __TPL_object_TYPE__: OptionsObjectType;
+};
+declare type OptionsTemplateValueNonEnum<T extends OptionsTemplateNativeTypes> = OptionsTemplateType<T> | [OptionsTemplateType<T>, ...Array<OptionsTemplateTypes>];
+declare type ExtractPropsKey<T, TProps extends T[keyof T]> = {
+    [P in keyof T]: TProps extends T[P] ? P : never;
+}[keyof T];
+declare type OptionsTemplateTypesDictionary = {
+    readonly boolean: OptionsTemplateType<boolean>;
+    readonly number: OptionsTemplateType<number>;
+    readonly string: OptionsTemplateType<string>;
+    readonly array: OptionsTemplateType<Array<any>>;
+    readonly object: OptionsTemplateType<OptionsObjectType>;
+    readonly function: OptionsTemplateType<OptionsFunctionType>;
+    readonly null: OptionsTemplateType<null>;
+};
 /**
  * A object which serves as a mapping for "normal" types and template types.
  * Key   = normal type string
@@ -23,14 +60,5 @@ declare const optionsTemplateTypes: OptionsTemplateTypesDictionary;
  * Without the optionsDiff object the returned validated object would be: { a: 'a', b: 'b', c: 'c' }
  * @param doWriteErrors True if errors shall be logged into the console, false otherwise.
  */
-declare const validateOptions: <T extends PlainObject<any>>(options: T, template: OptionsTemplate<Required<T>>, optionsDiff?: T | null | undefined, doWriteErrors?: boolean | undefined) => OptionsValidationResult<T>;
+declare const validateOptions: <T extends PlainObject<any>>(options: PartialOptions<T>, template: OptionsTemplate<T>, optionsDiff?: T | null | undefined, doWriteErrors?: boolean | undefined) => OptionsValidationResult<T>;
 export { validateOptions, optionsTemplateTypes };
-declare type OptionsTemplateTypesDictionary = {
-    readonly boolean: OptionsTemplateType<boolean>;
-    readonly number: OptionsTemplateType<number>;
-    readonly string: OptionsTemplateType<string>;
-    readonly array: OptionsTemplateType<Array<any>>;
-    readonly object: OptionsTemplateType<Record<string, unknown>>;
-    readonly function: OptionsTemplateType<Func>;
-    readonly null: OptionsTemplateType<null>;
-};

packages/overlayscrollbars/types/typings.d.ts

@@ -16,13 +16,15 @@ export declare type OSTargetElement = HTMLElement | HTMLTextAreaElement;
  * If element is provided, the provided element takes all its responsibilities.
  * DOM hierarchy isn't checked in this case, its assumed that hieararchy is correct in such a case.
  *
- * If element is null it won't be generated, and the responsibilities (feautes) of this element are lost.
+ * Undefined means that the plugin decides whether the respective element needs to be added or can be savely omitted.
+ * True means that even if the plugin would decide to not generate the element, the element is still generated.
+ * False means that event if the plugin would decide to generate the element, the element won't be generated.
  */
 export interface OSTargetObject {
     target: OSTargetElement;
     host?: HTMLElement;
-    padding?: HTMLElement | null;
+    padding?: HTMLElement | boolean;
     viewport?: HTMLElement;
-    content?: HTMLElement | null;
+    content?: HTMLElement | boolean;
 }
 export declare type OSTarget = OSTargetElement | OSTargetObject;