@dotss/ui 0.0.6 → 0.0.8

package/node_modules/@testing-library/user-event/dist/esm/clipboard/paste.js

@@ -1,23 +0,0 @@
-import { createDataTransfer } from '../utils/dataTransfer/DataTransfer.js';
-import { readDataTransferFromClipboard } from '../utils/dataTransfer/Clipboard.js';
-import { getWindow } from '../utils/misc/getWindow.js';
-
-async function paste(clipboardData) {
-    const doc = this.config.document;
-    var _doc_activeElement;
-    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== undefined ? _doc_activeElement : /* istanbul ignore next */ doc.body;
-    var _ref;
-    const dataTransfer = (_ref = typeof clipboardData === 'string' ? getClipboardDataFromString(doc, clipboardData) : clipboardData) !== null && _ref !== undefined ? _ref : await readDataTransferFromClipboard(doc).catch(()=>{
-        throw new Error('`userEvent.paste()` without `clipboardData` requires the `ClipboardAPI` to be available.');
-    });
-    this.dispatchUIEvent(target, 'paste', {
-        clipboardData: dataTransfer
-    });
-}
-function getClipboardDataFromString(doc, text) {
-    const dt = createDataTransfer(getWindow(doc));
-    dt.setData('text', text);
-    return dt;
-}
-
-export { paste };

package/node_modules/@testing-library/user-event/dist/esm/convenience/click.js

@@ -1,31 +0,0 @@
-async function click(element) {
-    const pointerIn = [];
-    if (!this.config.skipHover) {
-        pointerIn.push({
-            target: element
-        });
-    }
-    pointerIn.push({
-        keys: '[MouseLeft]',
-        target: element
-    });
-    return this.pointer(pointerIn);
-}
-async function dblClick(element) {
-    return this.pointer([
-        {
-            target: element
-        },
-        '[MouseLeft][MouseLeft]'
-    ]);
-}
-async function tripleClick(element) {
-    return this.pointer([
-        {
-            target: element
-        },
-        '[MouseLeft][MouseLeft][MouseLeft]'
-    ]);
-}
-
-export { click, dblClick, tripleClick };

package/node_modules/@testing-library/user-event/dist/esm/convenience/hover.js

@@ -1,16 +0,0 @@
-import '../utils/dataTransfer/Clipboard.js';
-import { assertPointerEvents } from '../utils/pointer/cssPointerEvents.js';
-
-async function hover(element) {
-    return this.pointer({
-        target: element
-    });
-}
-async function unhover(element) {
-    assertPointerEvents(this, this.system.pointer.getMouseTarget(this));
-    return this.pointer({
-        target: element.ownerDocument.body
-    });
-}
-
-export { hover, unhover };

package/node_modules/@testing-library/user-event/dist/esm/convenience/index.js

@@ -1,3 +0,0 @@
-export { click, dblClick, tripleClick } from './click.js';
-export { hover, unhover } from './hover.js';
-export { tab } from './tab.js';

package/node_modules/@testing-library/user-event/dist/esm/convenience/tab.js

@@ -1,5 +0,0 @@
-async function tab({ shift } = {}) {
-    return this.keyboard(shift === true ? '{Shift>}{Tab}{/Shift}' : shift === false ? '[/ShiftLeft][/ShiftRight]{Tab}' : '{Tab}');
-}
-
-export { tab };

package/node_modules/@testing-library/user-event/dist/esm/document/UI.js

@@ -1,79 +0,0 @@
-const UIValue = Symbol('Displayed value in UI');
-const UISelection = Symbol('Displayed selection in UI');
-const InitialValue = Symbol('Initial value to compare on blur');
-function isUIValue(value) {
-    return typeof value === 'object' && UIValue in value;
-}
-function isUISelectionStart(start) {
-    return !!start && typeof start === 'object' && UISelection in start;
-}
-function setUIValue(element, value) {
-    if (element[InitialValue] === undefined) {
-        element[InitialValue] = element.value;
-    }
-    element[UIValue] = value;
-    // eslint-disable-next-line no-new-wrappers
-    element.value = Object.assign(new String(value), {
-        [UIValue]: true
-    });
-}
-function getUIValue(element) {
-    return element[UIValue] === undefined ? element.value : String(element[UIValue]);
-}
-/** Flag the IDL value as clean. This does not change the value.*/ function setUIValueClean(element) {
-    element[UIValue] = undefined;
-}
-function clearInitialValue(element) {
-    element[InitialValue] = undefined;
-}
-function getInitialValue(element) {
-    return element[InitialValue];
-}
-function setUISelectionRaw(element, selection) {
-    element[UISelection] = selection;
-}
-function setUISelection(element, { focusOffset: focusOffsetParam, anchorOffset: anchorOffsetParam = focusOffsetParam }, mode = 'replace') {
-    const valueLength = getUIValue(element).length;
-    const sanitizeOffset = (o)=>Math.max(0, Math.min(valueLength, o));
-    const anchorOffset = mode === 'replace' || element[UISelection] === undefined ? sanitizeOffset(anchorOffsetParam) : element[UISelection].anchorOffset;
-    const focusOffset = sanitizeOffset(focusOffsetParam);
-    const startOffset = Math.min(anchorOffset, focusOffset);
-    const endOffset = Math.max(anchorOffset, focusOffset);
-    element[UISelection] = {
-        anchorOffset,
-        focusOffset
-    };
-    if (element.selectionStart === startOffset && element.selectionEnd === endOffset) {
-        return;
-    }
-    // eslint-disable-next-line no-new-wrappers
-    const startObj = Object.assign(new Number(startOffset), {
-        [UISelection]: true
-    });
-    try {
-        element.setSelectionRange(startObj, endOffset);
-    } catch  {
-    // DOMException for invalid state is expected when calling this
-    // on an element without support for setSelectionRange
-    }
-}
-function getUISelection(element) {
-    var _element_selectionStart, _element_selectionEnd, _element_UISelection;
-    const sel = (_element_UISelection = element[UISelection]) !== null && _element_UISelection !== undefined ? _element_UISelection : {
-        anchorOffset: (_element_selectionStart = element.selectionStart) !== null && _element_selectionStart !== undefined ? _element_selectionStart : 0,
-        focusOffset: (_element_selectionEnd = element.selectionEnd) !== null && _element_selectionEnd !== undefined ? _element_selectionEnd : 0
-    };
-    return {
-        ...sel,
-        startOffset: Math.min(sel.anchorOffset, sel.focusOffset),
-        endOffset: Math.max(sel.anchorOffset, sel.focusOffset)
-    };
-}
-function hasUISelection(element) {
-    return !!element[UISelection];
-}
-/** Flag the IDL selection as clean. This does not change the selection. */ function setUISelectionClean(element) {
-    element[UISelection] = undefined;
-}
-
-export { clearInitialValue, getInitialValue, getUISelection, getUIValue, hasUISelection, isUISelectionStart, isUIValue, setUISelection, setUISelectionClean, setUISelectionRaw, setUIValue, setUIValueClean };

package/node_modules/@testing-library/user-event/dist/esm/document/copySelection.js

@@ -1,27 +0,0 @@
-import { createDataTransfer } from '../utils/dataTransfer/DataTransfer.js';
-import '../utils/dataTransfer/Clipboard.js';
-import { getWindow } from '../utils/misc/getWindow.js';
-import { hasOwnSelection } from '../utils/focus/selection.js';
-import { getUISelection, getUIValue } from './UI.js';
-
-function copySelection(target) {
-    const data = hasOwnSelection(target) ? {
-        'text/plain': readSelectedValueFromInput(target)
-    } : {
-        'text/plain': String(target.ownerDocument.getSelection())
-    };
-    const dt = createDataTransfer(getWindow(target));
-    for(const type in data){
-        if (data[type]) {
-            dt.setData(type, data[type]);
-        }
-    }
-    return dt;
-}
-function readSelectedValueFromInput(target) {
-    const sel = getUISelection(target);
-    const val = getUIValue(target);
-    return val.substring(sel.startOffset, sel.endOffset);
-}
-
-export { copySelection };

package/node_modules/@testing-library/user-event/dist/esm/document/getValueOrTextContent.js

@@ -1,16 +0,0 @@
-import '../utils/dataTransfer/Clipboard.js';
-import { isContentEditable } from '../utils/edit/isContentEditable.js';
-import { getUIValue } from './UI.js';
-
-function getValueOrTextContent(element) {
-    // istanbul ignore if
-    if (!element) {
-        return null;
-    }
-    if (isContentEditable(element)) {
-        return element.textContent;
-    }
-    return getUIValue(element);
-}
-
-export { getValueOrTextContent };

package/node_modules/@testing-library/user-event/dist/esm/document/index.js

@@ -1,4 +0,0 @@
-export { clearInitialValue, getUISelection, getUIValue, setUISelection, setUIValue } from './UI.js';
-export { getValueOrTextContent } from './getValueOrTextContent.js';
-export { copySelection } from './copySelection.js';
-export { commitValueAfterInput } from './trackValue.js';

package/node_modules/@testing-library/user-event/dist/esm/document/interceptor.js

@@ -1,99 +0,0 @@
-import { isElementType } from '../utils/misc/isElementType.js';
-import '../utils/dataTransfer/Clipboard.js';
-import { startTrackValue, trackOrSetValue } from './trackValue.js';
-import { setUISelectionClean, setUISelectionRaw, getUIValue, setUIValueClean, isUIValue, isUISelectionStart } from './UI.js';
-
-const Interceptor = Symbol('Interceptor for programmatical calls');
-function prepareInterceptor(element, propName, interceptorImpl) {
-    const prototypeDescriptor = Object.getOwnPropertyDescriptor(element.constructor.prototype, propName);
-    const objectDescriptor = Object.getOwnPropertyDescriptor(element, propName);
-    const target = (prototypeDescriptor === null || prototypeDescriptor === undefined ? undefined : prototypeDescriptor.set) ? 'set' : 'value';
-    /* istanbul ignore if */ if (typeof (prototypeDescriptor === null || prototypeDescriptor === undefined ? undefined : prototypeDescriptor[target]) !== 'function' || prototypeDescriptor[target][Interceptor]) {
-        throw new Error(`Element ${element.tagName} does not implement "${String(propName)}".`);
-    }
-    function intercept(...args) {
-        const { applyNative = false, realArgs, then } = interceptorImpl.call(this, ...args);
-        const realFunc = (!applyNative && objectDescriptor || prototypeDescriptor)[target];
-        if (target === 'set') {
-            realFunc.call(this, realArgs);
-        } else {
-            realFunc.call(this, ...realArgs);
-        }
-        then === null || then === undefined ? undefined : then();
-    }
-    intercept[Interceptor] = Interceptor;
-    Object.defineProperty(element, propName, {
-        ...objectDescriptor !== null && objectDescriptor !== undefined ? objectDescriptor : prototypeDescriptor,
-        [target]: intercept
-    });
-}
-function prepareValueInterceptor(element) {
-    prepareInterceptor(element, 'value', function interceptorImpl(v) {
-        const isUI = isUIValue(v);
-        if (isUI) {
-            startTrackValue(this);
-        }
-        return {
-            applyNative: !!isUI,
-            realArgs: sanitizeValue(this, v),
-            then: isUI ? undefined : ()=>trackOrSetValue(this, String(v))
-        };
-    });
-}
-function sanitizeValue(element, v) {
-    // Workaround for JSDOM
-    if (isElementType(element, 'input', {
-        type: 'number'
-    }) && String(v) !== '' && !Number.isNaN(Number(v))) {
-        // Setting value to "1." results in `null` in JSDOM
-        return String(Number(v));
-    }
-    return String(v);
-}
-function prepareSelectionInterceptor(element) {
-    prepareInterceptor(element, 'setSelectionRange', function interceptorImpl(start, ...others) {
-        const isUI = isUISelectionStart(start);
-        return {
-            applyNative: !!isUI,
-            realArgs: [
-                Number(start),
-                ...others
-            ],
-            then: ()=>isUI ? undefined : setUISelectionClean(element)
-        };
-    });
-    prepareInterceptor(element, 'selectionStart', function interceptorImpl(v) {
-        return {
-            realArgs: v,
-            then: ()=>setUISelectionClean(element)
-        };
-    });
-    prepareInterceptor(element, 'selectionEnd', function interceptorImpl(v) {
-        return {
-            realArgs: v,
-            then: ()=>setUISelectionClean(element)
-        };
-    });
-    prepareInterceptor(element, 'select', function interceptorImpl() {
-        return {
-            realArgs: [],
-            then: ()=>setUISelectionRaw(element, {
-                    anchorOffset: 0,
-                    focusOffset: getUIValue(element).length
-                })
-        };
-    });
-}
-function prepareRangeTextInterceptor(element) {
-    prepareInterceptor(element, 'setRangeText', function interceptorImpl(...realArgs) {
-        return {
-            realArgs,
-            then: ()=>{
-                setUIValueClean(element);
-                setUISelectionClean(element);
-            }
-        };
-    });
-}
-
-export { prepareInterceptor, prepareRangeTextInterceptor, prepareSelectionInterceptor, prepareValueInterceptor };

package/node_modules/@testing-library/user-event/dist/esm/document/patchFocus.js

@@ -1,101 +0,0 @@
-import { dispatchDOMEvent } from '../event/dispatchEvent.js';
-import '../utils/dataTransfer/Clipboard.js';
-import { getActiveElement } from '../utils/focus/getActiveElement.js';
-import '@testing-library/dom';
-
-const patched = Symbol('patched focus/blur methods');
-function patchFocus(HTMLElement) {
-    if (HTMLElement.prototype[patched]) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const { focus, blur } = HTMLElement.prototype;
-    Object.defineProperties(HTMLElement.prototype, {
-        focus: {
-            configurable: true,
-            get: ()=>patchedFocus
-        },
-        blur: {
-            configurable: true,
-            get: ()=>patchedBlur
-        },
-        [patched]: {
-            configurable: true,
-            get: ()=>({
-                    focus,
-                    blur
-                })
-        }
-    });
-    let activeCall;
-    function patchedFocus(options) {
-        if (this.ownerDocument.visibilityState !== 'hidden') {
-            return focus.call(this, options);
-        }
-        const blurred = getActiveTarget(this.ownerDocument);
-        if (blurred === this) {
-            return;
-        }
-        const thisCall = Symbol('focus call');
-        activeCall = thisCall;
-        if (blurred) {
-            blur.call(blurred);
-            dispatchDOMEvent(blurred, 'blur', {
-                relatedTarget: this
-            });
-            dispatchDOMEvent(blurred, 'focusout', {
-                relatedTarget: activeCall === thisCall ? this : null
-            });
-        }
-        if (activeCall === thisCall) {
-            focus.call(this, options);
-            dispatchDOMEvent(this, 'focus', {
-                relatedTarget: blurred
-            });
-        }
-        if (activeCall === thisCall) {
-            dispatchDOMEvent(this, 'focusin', {
-                relatedTarget: blurred
-            });
-        }
-    }
-    function patchedBlur() {
-        if (this.ownerDocument.visibilityState !== 'hidden') {
-            return blur.call(this);
-        }
-        const blurred = getActiveTarget(this.ownerDocument);
-        if (blurred !== this) {
-            return;
-        }
-        const thisCall = Symbol('blur call');
-        activeCall = thisCall;
-        blur.call(this);
-        dispatchDOMEvent(blurred, 'blur', {
-            relatedTarget: null
-        });
-        dispatchDOMEvent(blurred, 'focusout', {
-            relatedTarget: null
-        });
-    }
-}
-function getActiveTarget(document) {
-    const active = getActiveElement(document);
-    return (active === null || active === undefined ? undefined : active.tagName) === 'BODY' ? null : active;
-}
-function restoreFocus(HTMLElement) {
-    if (HTMLElement.prototype[patched]) {
-        const { focus, blur } = HTMLElement.prototype[patched];
-        Object.defineProperties(HTMLElement.prototype, {
-            focus: {
-                configurable: true,
-                get: ()=>focus
-            },
-            blur: {
-                configurable: true,
-                get: ()=>blur
-            }
-        });
-    }
-}
-
-export { patchFocus, restoreFocus };

package/node_modules/@testing-library/user-event/dist/esm/document/prepareDocument.js

@@ -1,56 +0,0 @@
-import { dispatchDOMEvent } from '../event/dispatchEvent.js';
-import { isElementType } from '../utils/misc/isElementType.js';
-import '../utils/dataTransfer/Clipboard.js';
-import { getInitialValue, clearInitialValue } from './UI.js';
-import '@testing-library/dom';
-import { prepareValueInterceptor, prepareSelectionInterceptor, prepareRangeTextInterceptor } from './interceptor.js';
-
-const isPrepared = Symbol('Node prepared with document state workarounds');
-function prepareDocument(document) {
-    if (document[isPrepared]) {
-        return;
-    }
-    document.addEventListener('focus', (e)=>{
-        const el = e.target;
-        prepareElement(el);
-    }, {
-        capture: true,
-        passive: true
-    });
-    // Our test environment defaults to `document.body` as `activeElement`.
-    // In other environments this might be `null` when preparing.
-    // istanbul ignore else
-    if (document.activeElement) {
-        prepareElement(document.activeElement);
-    }
-    document.addEventListener('blur', (e)=>{
-        const el = e.target;
-        const initialValue = getInitialValue(el);
-        if (initialValue !== undefined) {
-            if (el.value !== initialValue) {
-                dispatchDOMEvent(el, 'change');
-            }
-            clearInitialValue(el);
-        }
-    }, {
-        capture: true,
-        passive: true
-    });
-    document[isPrepared] = isPrepared;
-}
-function prepareElement(el) {
-    if (el[isPrepared]) {
-        return;
-    }
-    if (isElementType(el, [
-        'input',
-        'textarea'
-    ])) {
-        prepareValueInterceptor(el);
-        prepareSelectionInterceptor(el);
-        prepareRangeTextInterceptor(el);
-    }
-    el[isPrepared] = isPrepared;
-}
-
-export { prepareDocument };

package/node_modules/@testing-library/user-event/dist/esm/document/trackValue.js

@@ -1,53 +0,0 @@
-import '../utils/dataTransfer/Clipboard.js';
-import { getWindow } from '../utils/misc/getWindow.js';
-import { setUIValueClean, setUISelection, hasUISelection } from './UI.js';
-
-const TrackChanges = Symbol('Track programmatic changes for React workaround');
-// When the input event happens in the browser, React executes all event handlers
-// and if they change state of a controlled value, nothing happens.
-// But when we trigger the event handlers in test environment with React@17,
-// the changes are rolled back before the state update is applied.
-// This results in a reset cursor.
-// There might be a better way to work around if we figure out
-// why the batched update is executed differently in our test environment.
-function isReact17Element(element) {
-    return Object.getOwnPropertyNames(element).some((k)=>k.startsWith('__react')) && getWindow(element).REACT_VERSION === 17;
-}
-function startTrackValue(element) {
-    if (!isReact17Element(element)) {
-        return;
-    }
-    element[TrackChanges] = {
-        previousValue: String(element.value),
-        tracked: []
-    };
-}
-function trackOrSetValue(element, v) {
-    var _element_TrackChanges_tracked, _element_TrackChanges;
-    (_element_TrackChanges = element[TrackChanges]) === null || _element_TrackChanges === undefined ? undefined : (_element_TrackChanges_tracked = _element_TrackChanges.tracked) === null || _element_TrackChanges_tracked === undefined ? undefined : _element_TrackChanges_tracked.push(v);
-    if (!element[TrackChanges]) {
-        setUIValueClean(element);
-        setUISelection(element, {
-            focusOffset: v.length
-        });
-    }
-}
-function commitValueAfterInput(element, cursorOffset) {
-    var _changes_tracked;
-    const changes = element[TrackChanges];
-    element[TrackChanges] = undefined;
-    if (!(changes === null || changes === undefined ? undefined : (_changes_tracked = changes.tracked) === null || _changes_tracked === undefined ? undefined : _changes_tracked.length)) {
-        return;
-    }
-    const isJustReactStateUpdate = changes.tracked.length === 2 && changes.tracked[0] === changes.previousValue && changes.tracked[1] === element.value;
-    if (!isJustReactStateUpdate) {
-        setUIValueClean(element);
-    }
-    if (hasUISelection(element)) {
-        setUISelection(element, {
-            focusOffset: isJustReactStateUpdate ? cursorOffset : element.value.length
-        });
-    }
-}
-
-export { commitValueAfterInput, startTrackValue, trackOrSetValue };

package/node_modules/@testing-library/user-event/dist/esm/event/behavior/click.js

@@ -1,30 +0,0 @@
-import { isElementType } from '../../utils/misc/isElementType.js';
-import '../../utils/dataTransfer/Clipboard.js';
-import { getWindow } from '../../utils/misc/getWindow.js';
-import { isFocusable } from '../../utils/focus/isFocusable.js';
-import { cloneEvent } from '../../utils/misc/cloneEvent.js';
-import { focusElement, blurElement } from '../focus.js';
-import { behavior } from './registry.js';
-
-behavior.click = (event, target, instance)=>{
-    const context = target.closest('button,input,label,select,textarea');
-    const control = context && isElementType(context, 'label') && context.control;
-    if (control && control !== target) {
-        return ()=>{
-            if (isFocusable(control)) {
-                focusElement(control);
-                instance.dispatchEvent(control, cloneEvent(event));
-            }
-        };
-    } else if (isElementType(target, 'input', {
-        type: 'file'
-    })) {
-        return ()=>{
-            // blur fires when the file selector pops up
-            blurElement(target);
-            target.dispatchEvent(new (getWindow(target)).Event('fileDialog'));
-            // focus fires after the file selector has been closed
-            focusElement(target);
-        };
-    }
-};

package/node_modules/@testing-library/user-event/dist/esm/event/behavior/cut.js

@@ -1,12 +0,0 @@
-import '../../utils/dataTransfer/Clipboard.js';
-import { isEditable } from '../../utils/edit/isEditable.js';
-import { input } from '../input.js';
-import { behavior } from './registry.js';
-
-behavior.cut = (event, target, instance)=>{
-    return ()=>{
-        if (isEditable(target)) {
-            input(instance, target, '', 'deleteByCut');
-        }
-    };
-};

package/node_modules/@testing-library/user-event/dist/esm/event/behavior/index.js

@@ -1,7 +0,0 @@
-import './click.js';
-import './cut.js';
-import './keydown.js';
-import './keypress.js';
-import './keyup.js';
-import './paste.js';
-export { behavior } from './registry.js';