@rstest/core 0.6.1 → 0.6.3

package/dist/0~350.js

@@ -1,380 +1,36 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "350";
-export const __webpack_ids__ = [
-    "350"
-];
-export const __webpack_modules__ = {
-    "./src/runtime/worker/env/happyDom.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            environment: ()=>environment
+import { checkPkgInstalled } from "./worker.js";
+import { installGlobal, addDefaultErrorHandler } from "./0~463.js";
+const environment = {
+    name: 'happy-dom',
+    async setup (global, { happyDom = {} }) {
+        checkPkgInstalled('happy-dom');
+        const { Window } = await import("happy-dom");
+        const win = new Window({
+            ...happyDom,
+            url: happyDom.url || 'http://localhost:3000',
+            console: console && global.console ? global.console : void 0
         });
-        var _util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/runtime/util.ts");
-        var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/runtime/worker/env/utils.ts");
-        const environment = {
-            name: 'happy-dom',
-            async setup (global, { happyDom = {} }) {
-                (0, _util__WEBPACK_IMPORTED_MODULE_0__.DW)('happy-dom');
-                const { Window } = await import("happy-dom");
-                const win = new Window({
-                    ...happyDom,
-                    url: happyDom.url || 'http://localhost:3000',
-                    console: console && global.console ? global.console : void 0
-                });
-                const cleanupGlobal = (0, _utils__WEBPACK_IMPORTED_MODULE_1__.p5)(global, win, {
-                    additionalKeys: [
-                        'Request',
-                        'Response',
-                        'MessagePort',
-                        'fetch'
-                    ]
-                });
-                const cleanupHandler = (0, _utils__WEBPACK_IMPORTED_MODULE_1__.d1)(global);
-                return {
-                    async teardown () {
-                        cleanupHandler();
-                        if (win.close && win.happyDOM.abort) {
-                            await win.happyDOM.abort();
-                            win.close();
-                        } else await win.happyDOM.cancelAsync();
-                        cleanupGlobal();
-                    }
-                };
-            }
-        };
-    },
-    "./src/runtime/worker/env/utils.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            d1: ()=>addDefaultErrorHandler,
-            p5: ()=>installGlobal
+        const cleanupGlobal = installGlobal(global, win, {
+            additionalKeys: [
+                'Request',
+                'Response',
+                'MessagePort',
+                'fetch'
+            ]
         });
-        const LIVING_KEYS = [
-            'DOMException',
-            'URL',
-            'URLSearchParams',
-            'EventTarget',
-            'NamedNodeMap',
-            'Node',
-            'Attr',
-            'Element',
-            'DocumentFragment',
-            'DOMImplementation',
-            'Document',
-            'XMLDocument',
-            'CharacterData',
-            'Text',
-            'CDATASection',
-            'ProcessingInstruction',
-            'Comment',
-            'DocumentType',
-            'NodeList',
-            'RadioNodeList',
-            'HTMLCollection',
-            'HTMLOptionsCollection',
-            'DOMStringMap',
-            'DOMTokenList',
-            'StyleSheetList',
-            'HTMLElement',
-            'HTMLHeadElement',
-            'HTMLTitleElement',
-            'HTMLBaseElement',
-            'HTMLLinkElement',
-            'HTMLMetaElement',
-            'HTMLStyleElement',
-            'HTMLBodyElement',
-            'HTMLHeadingElement',
-            'HTMLParagraphElement',
-            'HTMLHRElement',
-            'HTMLPreElement',
-            'HTMLUListElement',
-            'HTMLOListElement',
-            'HTMLLIElement',
-            'HTMLMenuElement',
-            'HTMLDListElement',
-            'HTMLDivElement',
-            'HTMLAnchorElement',
-            'HTMLAreaElement',
-            'HTMLBRElement',
-            'HTMLButtonElement',
-            'HTMLCanvasElement',
-            'HTMLDataElement',
-            'HTMLDataListElement',
-            'HTMLDetailsElement',
-            'HTMLDialogElement',
-            'HTMLDirectoryElement',
-            'HTMLFieldSetElement',
-            'HTMLFontElement',
-            'HTMLFormElement',
-            'HTMLHtmlElement',
-            'HTMLImageElement',
-            'HTMLInputElement',
-            'HTMLLabelElement',
-            'HTMLLegendElement',
-            'HTMLMapElement',
-            'HTMLMarqueeElement',
-            'HTMLMediaElement',
-            'HTMLMeterElement',
-            'HTMLModElement',
-            'HTMLOptGroupElement',
-            'HTMLOptionElement',
-            'HTMLOutputElement',
-            'HTMLPictureElement',
-            'HTMLProgressElement',
-            'HTMLQuoteElement',
-            'HTMLScriptElement',
-            'HTMLSelectElement',
-            'HTMLSlotElement',
-            'HTMLSourceElement',
-            'HTMLSpanElement',
-            'HTMLTableCaptionElement',
-            'HTMLTableCellElement',
-            'HTMLTableColElement',
-            'HTMLTableElement',
-            'HTMLTimeElement',
-            'HTMLTableRowElement',
-            'HTMLTableSectionElement',
-            'HTMLTemplateElement',
-            'HTMLTextAreaElement',
-            'HTMLUnknownElement',
-            'HTMLFrameElement',
-            'HTMLFrameSetElement',
-            'HTMLIFrameElement',
-            'HTMLEmbedElement',
-            'HTMLObjectElement',
-            'HTMLParamElement',
-            'HTMLVideoElement',
-            'HTMLAudioElement',
-            'HTMLTrackElement',
-            'HTMLFormControlsCollection',
-            'SVGElement',
-            'SVGGraphicsElement',
-            'SVGSVGElement',
-            'SVGGElement',
-            'SVGDefsElement',
-            'SVGDescElement',
-            'SVGMetadataElement',
-            'SVGTitleElement',
-            'SVGSymbolElement',
-            'SVGSwitchElement',
-            'SVGAnimatedPreserveAspectRatio',
-            'SVGAnimatedRect',
-            'SVGAnimatedString',
-            'SVGNumber',
-            'SVGPreserveAspectRatio',
-            'SVGRect',
-            'SVGStringList',
-            'Event',
-            'BeforeUnloadEvent',
-            'BlobEvent',
-            'CloseEvent',
-            'CustomEvent',
-            'MessageEvent',
-            'ErrorEvent',
-            'HashChangeEvent',
-            'PopStateEvent',
-            'StorageEvent',
-            'ProgressEvent',
-            'PageTransitionEvent',
-            'SubmitEvent',
-            'UIEvent',
-            'FocusEvent',
-            'InputEvent',
-            'MouseEvent',
-            'KeyboardEvent',
-            'TouchEvent',
-            'CompositionEvent',
-            'WheelEvent',
-            'BarProp',
-            'External',
-            'Location',
-            'History',
-            'Screen',
-            'Performance',
-            'Navigator',
-            'Crypto',
-            'PluginArray',
-            'MimeTypeArray',
-            'Plugin',
-            'MimeType',
-            'FileReader',
-            'Blob',
-            'File',
-            'FileList',
-            'ValidityState',
-            'DOMParser',
-            'XMLSerializer',
-            'FormData',
-            'XMLHttpRequestEventTarget',
-            'XMLHttpRequestUpload',
-            'XMLHttpRequest',
-            'WebSocket',
-            'NodeFilter',
-            'NodeIterator',
-            'TreeWalker',
-            'AbstractRange',
-            'Range',
-            'StaticRange',
-            'Selection',
-            'Storage',
-            'CustomElementRegistry',
-            'ElementInternals',
-            'ShadowRoot',
-            'MutationObserver',
-            'MutationRecord',
-            'Headers',
-            'AbortController',
-            'AbortSignal',
-            'Uint8Array',
-            'Uint16Array',
-            'Uint32Array',
-            'Uint8ClampedArray',
-            'Int8Array',
-            'Int16Array',
-            'Int32Array',
-            'Float32Array',
-            'Float64Array',
-            'ArrayBuffer',
-            'DeviceMotionEventAcceleration',
-            'DeviceMotionEventRotationRate',
-            'DOMRectReadOnly',
-            'DOMRect',
-            'Image',
-            'Audio',
-            'Option',
-            'CSS'
-        ];
-        const OTHER_KEYS = [
-            'addEventListener',
-            'alert',
-            'blur',
-            'cancelAnimationFrame',
-            'close',
-            'confirm',
-            'createPopup',
-            'dispatchEvent',
-            'document',
-            'focus',
-            'frames',
-            'getComputedStyle',
-            'history',
-            'innerHeight',
-            'innerWidth',
-            'length',
-            'location',
-            'matchMedia',
-            'moveBy',
-            'moveTo',
-            'name',
-            'navigator',
-            'open',
-            'outerHeight',
-            'outerWidth',
-            'pageXOffset',
-            'pageYOffset',
-            'parent',
-            'postMessage',
-            'print',
-            'prompt',
-            'removeEventListener',
-            'requestAnimationFrame',
-            'resizeBy',
-            'resizeTo',
-            'screen',
-            'screenLeft',
-            'screenTop',
-            'screenX',
-            'screenY',
-            'scroll',
-            'scrollBy',
-            'scrollLeft',
-            'scrollTo',
-            'scrollTop',
-            'scrollX',
-            'scrollY',
-            'self',
-            'stop',
-            'top',
-            'Window',
-            'window'
-        ];
-        const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
-        const SKIP_KEYS = [
-            'window',
-            'self',
-            'top',
-            'parent'
-        ];
-        function getWindowKeys(global, win, additionalKeys = []) {
-            const keysArray = [
-                ...additionalKeys,
-                ...KEYS
-            ];
-            return new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k)=>{
-                if (SKIP_KEYS.includes(k)) return false;
-                if (k in global) return keysArray.includes(k);
-                return true;
-            }));
-        }
-        function isClassLike(name) {
-            return name[0] === name[0]?.toUpperCase();
-        }
-        function installGlobal(global, win, options = {}) {
-            const { bindFunctions = true } = options || {};
-            const keys = getWindowKeys(global, win, options.additionalKeys);
-            const originals = new Map();
-            const overrides = new Map();
-            for (const key of keys){
-                const boundFunction = bindFunctions && 'function' == typeof win[key] && !isClassLike(key) && win[key].bind(win);
-                if (key in global) originals.set(key, global[key]);
-                Object.defineProperty(global, key, {
-                    get () {
-                        if (overrides.has(key)) return overrides.get(key);
-                        if (boundFunction) return boundFunction;
-                        return win[key];
-                    },
-                    set (v) {
-                        overrides.set(key, v);
-                    },
-                    configurable: true
-                });
+        const cleanupHandler = addDefaultErrorHandler(global);
+        return {
+            async teardown () {
+                cleanupHandler();
+                if (win.close && win.happyDOM.abort) {
+                    await win.happyDOM.abort();
+                    win.close();
+                } else await win.happyDOM.cancelAsync();
+                cleanupGlobal();
             }
-            global.window = global;
-            global.self = global;
-            global.top = global;
-            global.parent = global;
-            if (global.global) global.global = global;
-            if (global.document?.defaultView) Object.defineProperty(global.document, 'defaultView', {
-                get: ()=>global,
-                enumerable: true,
-                configurable: true
-            });
-            for (const k of SKIP_KEYS)keys.add(k);
-            return ()=>{
-                for (const key of keys)delete global[key];
-                originals.forEach((v, k)=>{
-                    global[k] = v;
-                });
-            };
-        }
-        function addDefaultErrorHandler(window) {
-            let userErrorListenerCount = 0;
-            const throwUnhandledError = (e)=>{
-                if (0 === userErrorListenerCount && null != e.error) process.emit('uncaughtException', e.error);
-            };
-            const addEventListener = window.addEventListener.bind(window);
-            const removeEventListener = window.removeEventListener.bind(window);
-            window.addEventListener('error', throwUnhandledError);
-            window.addEventListener = function(...args) {
-                if ('error' === args[0]) userErrorListenerCount++;
-                return addEventListener.apply(this, args);
-            };
-            window.removeEventListener = function(...args) {
-                if ('error' === args[0] && userErrorListenerCount) userErrorListenerCount--;
-                return removeEventListener.apply(this, args);
-            };
-            return ()=>{
-                window.removeEventListener('error', throwUnhandledError);
-            };
-        }
+        };
     }
 };
+export { environment };

package/dist/0~365.js

@@ -0,0 +1,92 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { src_logger, isTTY } from "./857.js";
+import { runRest } from "./index.js";
+const GLOB_REGEX = /[*?{}[\]()!@+|]/;
+const isGlob = (str)=>GLOB_REGEX.test(str);
+async function createChokidar(pathOrGlobs, root, options) {
+    const chokidar = await import("./0~263.js").then((mod)=>({
+            watch: mod.watch
+        }));
+    const watchFiles = new Set();
+    const globPatterns = pathOrGlobs.filter((pathOrGlob)=>{
+        if (isGlob(pathOrGlob)) return true;
+        watchFiles.add(pathOrGlob);
+        return false;
+    });
+    if (globPatterns.length) {
+        const { glob } = await import("./857.js").then((mod)=>({
+                glob: mod.glob
+            }));
+        const files = await glob(globPatterns, {
+            cwd: root,
+            absolute: true
+        });
+        for (const file of files)watchFiles.add(file);
+    }
+    return chokidar.watch(Array.from(watchFiles), options);
+}
+const external_node_path_ = __webpack_require__("node:path");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+let cleaners = [];
+const onBeforeRestart = (cleaner)=>{
+    cleaners.push(cleaner);
+};
+const clearConsole = ()=>{
+    if (isTTY() && !process.env.DEBUG) process.stdout.write('\x1B[H\x1B[2J');
+};
+const beforeRestart = async ({ filePath, root, clear = true })=>{
+    if (clear) clearConsole();
+    if (filePath) {
+        const filename = external_node_path_["default"].relative(root, filePath);
+        src_logger.info(`restarting Rstest as ${picocolors_default().yellow(filename)} changed\n`);
+    } else src_logger.info('restarting Rstest...\n');
+    for (const cleaner of cleaners)await cleaner();
+    cleaners = [];
+};
+const restart = async ({ filePath, clear = true, options, filters, root })=>{
+    await beforeRestart({
+        filePath,
+        root,
+        clear
+    });
+    await runRest({
+        options,
+        filters,
+        command: 'watch'
+    });
+    return true;
+};
+async function watchFilesForRestart({ rstest, watchOptions, options, filters }) {
+    const configFilePaths = [
+        rstest.context.configFilePath,
+        ...rstest.context.projects.map((project)=>project.configFilePath)
+    ].filter(Boolean);
+    if (0 === configFilePaths.length) return;
+    const root = rstest.context.rootPath;
+    const watcher = await createChokidar(configFilePaths, root, {
+        ignoreInitial: true,
+        ignorePermissionErrors: true,
+        ...watchOptions
+    });
+    let restarting = false;
+    const onChange = async (filePath)=>{
+        if (restarting) return;
+        restarting = true;
+        const restarted = await restart({
+            options,
+            root,
+            filters,
+            filePath
+        });
+        if (restarted) await watcher.close();
+        else src_logger.error('Restart failed');
+        restarting = false;
+    };
+    watcher.on('add', onChange);
+    watcher.on('change', onChange);
+    watcher.on('unlink', onChange);
+}
+export { onBeforeRestart, watchFilesForRestart };