@papillonarts/setup 0.48.0 → 0.49.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 MTS.
+Copyright (c) 2026 MTS.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/build/babel/index.d.ts

@@ -1,4 +1,6 @@
-export let presets: string[];
+export let presets: (string | (string | {
+    modules: string;
+})[])[];
 export let plugins: (string | (string | {
     runtime: string;
 })[])[];

package/build/babel/index.js

@@ -1,7 +1,12 @@
 "use strict";
 
 module.exports = {
-  presets: ['@babel/preset-env', '@babel/preset-react', '@babel/preset-typescript'],
+  // https://babeljs.io/docs/babel-preset-env#modules
+  // Babel 8 no longer defaults to CommonJS output; this config builds package "main"/build
+  // output (via generate-commonjs) and transforms Jest test files, both of which need require().
+  presets: [['@babel/preset-env', {
+    modules: 'commonjs'
+  }], '@babel/preset-react', '@babel/preset-typescript'],
   plugins: [['@babel/plugin-transform-react-jsx', {
     runtime: 'automatic'
   }], '@babel/plugin-transform-runtime', 'syntax-async-functions']

package/build/eslint/index.d.mts

@@ -1,4 +1,5 @@
-export function getESLintSetup({ eslintIgnores }: {
+export function getESLintSetup({ eslintIgnores, languageOptionsParserOptionsProject }: {
     eslintIgnores: any;
-}): import("eslint/config").Config[];
+    languageOptionsParserOptionsProject: any;
+}): import("eslint/config").ConfigObject[];
 //# sourceMappingURL=index.d.mts.map

package/build/eslint/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/eslint/index.mjs"],"names":[],"mappings":"AAwBA;;qCAqKC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/eslint/index.mjs"],"names":[],"mappings":"AAwBA;;;2CAsLC"}

package/build/eslint/index.mjs

@@ -22,7 +22,31 @@ const compat = new FlatCompat({
   allConfig: js.configs.all,
 })
 
-export function getESLintSetup({ eslintIgnores }) {
+export function getESLintSetup({ eslintIgnores, languageOptionsParserOptionsProject }) {
+  let parserOptions = {
+    ecmaFeatures: {
+      jsx: true,
+    },
+  }
+
+  if (!languageOptionsParserOptionsProject) {
+    parserOptions = {
+      ...parserOptions,
+
+      // https://typescript-eslint.io/packages/parser/#projectservice
+      projectService: {
+        allowDefaultProject: ['*.js', '*.jsx', '*.ts', '*.tsx', '*.d.ts'],
+      },
+    }
+  } else {
+    parserOptions = {
+      ...parserOptions,
+
+      // https://typescript-eslint.io/packages/parser/#project
+      project: languageOptionsParserOptionsProject,
+    }
+  }
+
   return defineConfig([
     globalIgnores(eslintIgnores),
     {
@@ -89,15 +113,7 @@ export function getESLintSetup({ eslintIgnores }) {
         ecmaVersion: 'latest',
         sourceType: 'module',
 
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true,
-          },
-
-          projectService: {
-            allowDefaultProject: ['*.js', '*.jsx', '*.ts', '*.tsx', '*.d.ts'],
-          },
-        },
+        parserOptions,
       },
 
       settings: {
@@ -180,6 +196,7 @@ export function getESLintSetup({ eslintIgnores }) {
         'comma-dangle': 0,
         'no-unused-vars': 'off',
         '@typescript-eslint/no-unused-vars': 'error',
+        '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports', fixStyle: 'separate-type-imports' }],
         // Testing Library rules
         'testing-library/prefer-screen-queries': 'error',
         'testing-library/prefer-presence-queries': 'error',

package/build/jest/config.d.ts

@@ -10,9 +10,6 @@ export declare function getJestSetup({ testPathIgnorePatterns, coverageDirectory
     globals?: {
         [x: string]: unknown;
     };
-    cache?: boolean;
-    resolver?: string;
-    roots?: string[];
     bail?: number | boolean;
     testPathIgnorePatterns?: string[];
     coverageDirectory?: string;
@@ -33,11 +30,13 @@ export declare function getJestSetup({ testPathIgnorePatterns, coverageDirectory
         }>>;
     };
     automock?: boolean;
+    cache?: boolean;
     cacheDirectory?: string;
     ci?: boolean;
     clearMocks?: boolean;
     changedFilesWithAncestor?: boolean;
     changedSince?: string;
+    collectTests?: boolean;
     coveragePathIgnorePatterns?: string[];
     coverageProvider?: "babel" | "v8";
     coverageReporters?: ("text" | "json" | "clover" | "cobertura" | "html-spa" | "html" | "json-summary" | "lcov" | "lcovonly" | "none" | "teamcity" | "text-lcov" | "text-summary" | ["text" | "json" | "clover" | "cobertura" | "html-spa" | "html" | "json-summary" | "lcov" | "lcovonly" | "none" | "teamcity" | "text-lcov" | "text-summary", {
@@ -56,7 +55,7 @@ export declare function getJestSetup({ testPathIgnorePatterns, coverageDirectory
         enableGlobally?: boolean;
     } & ({
         advanceTimers?: number | boolean;
-        doNotFake?: ("performance" | "Date" | "hrtime" | "nextTick" | "queueMicrotask" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "setTimeout" | "clearTimeout")[];
+        doNotFake?: ("queueMicrotask" | "setImmediate" | "performance" | "Date" | "hrtime" | "nextTick" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "clearImmediate" | "setInterval" | "clearInterval" | "setTimeout" | "clearTimeout" | "Temporal")[];
         now?: number;
         timerLimit?: number;
         legacyFakeTimers?: false;
@@ -114,9 +113,13 @@ export declare function getJestSetup({ testPathIgnorePatterns, coverageDirectory
     replname?: string;
     resetMocks?: boolean;
     resetModules?: boolean;
+    resolver?: string;
     restoreMocks?: boolean;
     rootDir?: string;
-    runner?: string;
+    roots?: string[];
+    runner?: string | [string, {
+        [x: string]: unknown;
+    }];
     runTestsByPath?: boolean;
     runtime?: string;
     sandboxInjectedGlobals?: string[];
@@ -179,5 +182,6 @@ export declare function getJestSetup({ testPathIgnorePatterns, coverageDirectory
     watchPlugins?: (string | [string, unknown])[];
     workerIdleMemoryLimit?: string | number;
     workerThreads?: boolean;
+    workerGracefulExitTimeout?: number;
 };
 //# sourceMappingURL=config.d.ts.map

package/build/jest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/jest/config.ts"],"names":[],"mappings":"AAsGA,eAAO,MAAM,uBAAuB,UAAyD,CAAA;AAE7F,wBAAgB,YAAY,CAAC,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,iBAAiB,EAAE;;;;;;CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BlI"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/jest/config.ts"],"names":[],"mappings":"AAyGA,eAAO,MAAM,uBAAuB,UAAyD,CAAA;AAE7F,wBAAgB,YAAY,CAAC,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,iBAAiB,EAAE;;;;;;CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BlI"}

package/build/jest/config.js

@@ -1,35 +1,34 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getJestSetup = getJestSetup;
 exports.transformIgnorePatterns = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _jestConfig = require("jest-config");
 // https://jestjs.io/docs/configuration
 // https://jestjs.io/docs/getting-started#using-typescript
 
-var transformIgnorePackages = ['@exodus', 'bail', 'ccount', 'character-entities', 'character-entities-legacy', 'character-reference-invalid', 'comma-separated-tokens', 'decode-named-character-reference', 'devlop', 'escape-string-regexp', 'estree-util-is-identifier-name', 'hast-util-parse-selector', 'hast-util-to-jsx-runtime', 'hast-util-whitespace', 'hastscript', 'html-url-attributes', 'is-alphabetical', 'is-alphanumerical', 'is-blank', 'is-decimal', 'is-hexadecimal', 'is-plain-obj', 'is-whitespace-like', 'jsdom/node_modules/parse5', 'longest-streak', 'markdown-table', 'mdast-util-find-and-replace', 'mdast-util-find-and-replace/node_modules/escape-string-regexp', 'mdast-util-from-markdown', 'mdast-util-gfm', 'mdast-util-gfm-autolink-literal', 'mdast-util-gfm-footnote', 'mdast-util-gfm-strikethrough', 'mdast-util-gfm-table', 'mdast-util-gfm-task-list-item', 'mdast-util-mdx-expression', 'mdast-util-mdx-jsx', 'mdast-util-mdxjs-esm', 'mdast-util-phrasing', 'mdast-util-to-hast', 'mdast-util-to-markdown', 'mdast-util-to-string', 'micromark', 'micromark-core-commonmark', 'micromark-extension-gfm', 'micromark-extension-gfm-autolink-literal', 'micromark-extension-gfm-footnote', 'micromark-extension-gfm-strikethrough', 'micromark-extension-gfm-table', 'micromark-extension-gfm-tagfilter', 'micromark-extension-gfm-task-list-item', 'micromark-factory-destination', 'micromark-factory-label', 'micromark-factory-space', 'micromark-factory-title', 'micromark-factory-whitespace', 'micromark-util-character', 'micromark-util-chunked', 'micromark-util-classify-character', 'micromark-util-combine-extensions', 'micromark-util-decode-numeric-character-reference', 'micromark-util-decode-string', 'micromark-util-encode', 'micromark-util-html-tag-name', 'micromark-util-normalize-identifier', 'micromark-util-resolve-all', 'micromark-util-sanitize-uri', 'micromark-util-subtokenize', 'micromark-util-symbol', 'micromark-util-types', 'parse-entities', 'parse5', 'property-information', 'react-markdown', 'react-syntax-highlighter', 'refractor', 'remark-gfm', 'remark-parse', 'remark-rehype', 'remark-stringify', 'space-separated-tokens', 'trim-lines', 'trough', 'unified', 'unified/node_modules/is-plain-obj', 'unist-util-is', 'unist-util-position', 'unist-util-stringify-position', 'unist-util-visit', 'unist-util-visit-parents', 'uuid', 'vfile', 'vfile-message', 'zwitch'].join('|');
-var transformIgnorePatterns = exports.transformIgnorePatterns = ["node_modules/(?!((@)?".concat(transformIgnorePackages, ")/)")];
-function getJestSetup(_ref) {
-  var testPathIgnorePatterns = _ref.testPathIgnorePatterns,
-    coverageDirectory = _ref.coverageDirectory,
-    collectCoverage = _ref.collectCoverage,
-    collectCoverageFrom = _ref.collectCoverageFrom,
-    coverageThreshold = _ref.coverageThreshold;
-  var config = {
+const transformIgnorePackages = ['@asamuzakjp', '@csstools', '@exodus', 'bail', 'ccount', 'character-entities', 'character-entities-legacy', 'character-reference-invalid', 'comma-separated-tokens', 'decode-named-character-reference', 'devlop', 'entities', 'escape-string-regexp', 'estree-util-is-identifier-name', 'hast-util-parse-selector', 'hast-util-to-jsx-runtime', 'hast-util-whitespace', 'hastscript', 'html-url-attributes', 'is-alphabetical', 'is-alphanumerical', 'is-blank', 'is-decimal', 'is-hexadecimal', 'is-plain-obj', 'is-whitespace-like', 'jsdom/node_modules/(parse5|entities)', 'longest-streak', 'markdown-table', 'mdast-util-find-and-replace', 'mdast-util-find-and-replace/node_modules/escape-string-regexp', 'mdast-util-from-markdown', 'mdast-util-gfm', 'mdast-util-gfm-autolink-literal', 'mdast-util-gfm-footnote', 'mdast-util-gfm-strikethrough', 'mdast-util-gfm-table', 'mdast-util-gfm-task-list-item', 'mdast-util-mdx-expression', 'mdast-util-mdx-jsx', 'mdast-util-mdxjs-esm', 'mdast-util-phrasing', 'mdast-util-to-hast', 'mdast-util-to-markdown', 'mdast-util-to-string', 'micromark', 'micromark-core-commonmark', 'micromark-extension-gfm', 'micromark-extension-gfm-autolink-literal', 'micromark-extension-gfm-footnote', 'micromark-extension-gfm-strikethrough', 'micromark-extension-gfm-table', 'micromark-extension-gfm-tagfilter', 'micromark-extension-gfm-task-list-item', 'micromark-factory-destination', 'micromark-factory-label', 'micromark-factory-space', 'micromark-factory-title', 'micromark-factory-whitespace', 'micromark-util-character', 'micromark-util-chunked', 'micromark-util-classify-character', 'micromark-util-combine-extensions', 'micromark-util-decode-numeric-character-reference', 'micromark-util-decode-string', 'micromark-util-encode', 'micromark-util-html-tag-name', 'micromark-util-normalize-identifier', 'micromark-util-resolve-all', 'micromark-util-sanitize-uri', 'micromark-util-subtokenize', 'micromark-util-symbol', 'micromark-util-types', 'parse-entities', 'parse5', 'property-information', 'react-markdown', 'react-syntax-highlighter', 'refractor', 'remark-gfm', 'remark-parse', 'remark-rehype', 'remark-stringify', 'space-separated-tokens', 'trim-lines', 'trough', 'unified', 'unified/node_modules/is-plain-obj', 'unist-util-is', 'unist-util-position', 'unist-util-stringify-position', 'unist-util-visit', 'unist-util-visit-parents', 'uuid', 'vfile', 'vfile-message', 'zwitch'].join('|');
+const transformIgnorePatterns = exports.transformIgnorePatterns = [`node_modules/(?!((@)?${transformIgnorePackages})/)`];
+function getJestSetup({
+  testPathIgnorePatterns,
+  coverageDirectory,
+  collectCoverage,
+  collectCoverageFrom,
+  coverageThreshold
+}) {
+  const config = {
     testMatch: ['**/?(*.)test.(js|ts)?(x)'],
-    testPathIgnorePatterns: testPathIgnorePatterns,
+    testPathIgnorePatterns,
     roots: ['<rootDir>'],
     transform: {
-      '^.+\\.(js|jsx|ts|tsx)$': 'babel-jest'
+      '^.+\\.(js|jsx|mjs|ts|tsx)$': 'babel-jest'
     },
-    coverageDirectory: coverageDirectory,
-    collectCoverage: collectCoverage,
+    coverageDirectory,
+    collectCoverage,
     coverageReporters: ['lcov', 'text'],
-    collectCoverageFrom: collectCoverageFrom,
+    collectCoverageFrom,
     // https://jest-extended.jestcommunity.dev/docs/getting-started/setup
     // https://jest-extended.jestcommunity.dev/docs/matchers
     setupFilesAfterEnv: ['@testing-library/jest-dom', '<rootDir>/jest.setup.js', 'jest-extended/all'],
@@ -38,13 +37,13 @@ function getJestSetup(_ref) {
       '^.+\\.(css|less|scss|md)$': 'identity-obj-proxy'
     },
     // https://jestjs.io/docs/tutorial-react-native#transformignorepatterns-customization
-    transformIgnorePatterns: transformIgnorePatterns,
-    moduleFileExtensions: ['js', 'jsx', 'ts', 'tsx'],
-    coverageThreshold: coverageThreshold,
+    transformIgnorePatterns,
+    moduleFileExtensions: ['js', 'jsx', 'mjs', 'ts', 'tsx'],
+    coverageThreshold,
     // https://github.com/storybookjs/addon-jest
     modulePathIgnorePatterns: ['<rootDir>/node_modules', '<rootDir>/jest-test-results.json'],
     // https://jestjs.io/docs/configuration#moduledirectories-arraystring
-    moduleDirectories: (0, _toConsumableArray2["default"])(_jestConfig.defaults.moduleDirectories)
+    moduleDirectories: [..._jestConfig.defaults.moduleDirectories]
   };
   return config;
 }

package/build/jest/index.js

@@ -5,37 +5,37 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "createMockStore", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utility.createMockStore;
   }
 });
 Object.defineProperty(exports, "getJestSetup", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _config.getJestSetup;
   }
 });
 Object.defineProperty(exports, "renderSnapshot", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utility.renderSnapshot;
   }
 });
 Object.defineProperty(exports, "renderSnapshotAsync", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utility.renderSnapshotAsync;
   }
 });
 Object.defineProperty(exports, "runJestSetup", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _setup.runJestSetup;
   }
 });
 Object.defineProperty(exports, "waitFor", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _utility.waitFor;
   }
 });

package/build/jest/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/jest/setup.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,CAAA;AAKhB,wBAAgB,YAAY,SAoH3B"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/jest/setup.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,CAAA;AAYhB,wBAAgB,YAAY,SAoH3B"}

package/build/jest/setup.js

@@ -1,19 +1,22 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.runJestSetup = runJestSetup;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 require("./jsdom");
 var _react = require("@testing-library/react");
 var _jestAxe = require("jest-axe");
+var _nodeBuffer = require("node:buffer");
 var _snapshotDiff = require("snapshot-diff");
 // https://github.com/jest-community/snapshot-diff
 // IMPORTANT: jsdom-global MUST be imported first to set up global document before testing-library imports
 
+// jsdom-global copies jsdom's window.atob/btoa onto the Node global, but those just
+// delegate to the ambient global atob/btoa — once copied, that delegation becomes
+// self-referential and throws/overflows. Restore Node's real implementations.
+global.atob = _nodeBuffer.atob;
+global.btoa = _nodeBuffer.btoa;
 function runJestSetup() {
   /**
    * Normalizes Date.prototype methods to output deterministic ISO-like UTC strings.
@@ -35,7 +38,7 @@ function runJestSetup() {
    * @returns {string} Padded string
    */
   function pad2(n) {
-    return n < 10 ? "0".concat(n) : "".concat(n);
+    return n < 10 ? `0${n}` : `${n}`;
   }
 
   /**
@@ -44,13 +47,13 @@ function runJestSetup() {
    * @returns {string} Formatted ISO-like date-time string
    */
   function formatAsISODateTime(date) {
-    var d = pad2(date.getUTCDate());
-    var m = pad2(date.getUTCMonth() + 1);
-    var y = date.getUTCFullYear();
-    var hh = pad2(date.getUTCHours());
-    var mm = pad2(date.getUTCMinutes());
-    var ss = pad2(date.getUTCSeconds());
-    return "".concat(y, "-").concat(m, "-").concat(d, "T").concat(hh, ":").concat(mm, ":").concat(ss, "Z");
+    const d = pad2(date.getUTCDate());
+    const m = pad2(date.getUTCMonth() + 1);
+    const y = date.getUTCFullYear();
+    const hh = pad2(date.getUTCHours());
+    const mm = pad2(date.getUTCMinutes());
+    const ss = pad2(date.getUTCSeconds());
+    return `${y}-${m}-${d}T${hh}:${mm}:${ss}Z`;
   }
 
   /**
@@ -59,10 +62,10 @@ function runJestSetup() {
    * @returns {string} Formatted ISO-like date string
    */
   function formatAsISODate(date) {
-    var d = pad2(date.getUTCDate());
-    var m = pad2(date.getUTCMonth() + 1);
-    var y = date.getUTCFullYear();
-    return "".concat(y, "-").concat(m, "-").concat(d);
+    const d = pad2(date.getUTCDate());
+    const m = pad2(date.getUTCMonth() + 1);
+    const y = date.getUTCFullYear();
+    return `${y}-${m}-${d}`;
   }
 
   /**
@@ -71,14 +74,14 @@ function runJestSetup() {
    * @returns {string} Formatted ISO-like time string
    */
   function formatAsISOTime(date) {
-    var hh = pad2(date.getUTCHours());
-    var mm = pad2(date.getUTCMinutes());
-    var ss = pad2(date.getUTCSeconds());
-    return "".concat(hh, ":").concat(mm, ":").concat(ss, "Z");
+    const hh = pad2(date.getUTCHours());
+    const mm = pad2(date.getUTCMinutes());
+    const ss = pad2(date.getUTCSeconds());
+    return `${hh}:${mm}:${ss}Z`;
   }
-  var originalToLocaleString = Date.prototype.toLocaleString;
-  var originalToLocaleDateString = Date.prototype.toLocaleDateString;
-  var originalToLocaleTimeString = Date.prototype.toLocaleTimeString;
+  const originalToLocaleString = Date.prototype.toLocaleString;
+  const originalToLocaleDateString = Date.prototype.toLocaleDateString;
+  const originalToLocaleTimeString = Date.prototype.toLocaleTimeString;
   Date.prototype.toLocaleString = function toLocaleStringPatched(locale, options) {
     if (!locale && !options) {
       return formatAsISODateTime(this);
@@ -107,31 +110,22 @@ function runJestSetup() {
   global.act = _react.act;
   global.fireEvent = _react.fireEvent;
   // Add MutationObserver polyfill for tests
-  global.MutationObserver = /*#__PURE__*/function () {
-    function _class(callback) {
-      (0, _classCallCheck2["default"])(this, _class);
+  global.MutationObserver = class {
+    callback;
+    constructor(callback) {
       this.callback = callback;
     }
-    return (0, _createClass2["default"])(_class, [{
-      key: "disconnect",
-      value: function disconnect() {}
-    }, {
-      key: "observe",
-      value: function observe() {
-        // Call the callback immediately to simulate initial observation
-        this.callback([], this);
-      }
-    }, {
-      key: "takeRecords",
-      value: function takeRecords() {
-        return [];
-      }
-    }]);
-  }();
-  global.render = _react.render;
-  global.renderToJSON = function (component) {
-    return (0, _react.render)(component).container;
+    disconnect() {}
+    observe() {
+      // Call the callback immediately to simulate initial observation
+      this.callback([], this);
+    }
+    takeRecords() {
+      return [];
+    }
   };
+  global.render = _react.render;
+  global.renderToJSON = component => (0, _react.render)(component).container;
   global.screen = _react.screen;
   expect.extend(_jestAxe.toHaveNoViolations);
   expect.extend({

package/build/jest/utility.js

@@ -1,12 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.waitFor = exports.renderSnapshotAsync = exports.renderSnapshot = exports.createMockStore = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 /* eslint-disable testing-library/no-unnecessary-act */
 /**
  * Shared test utilities provided by @papillonarts/setup/jest.
@@ -31,9 +28,7 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
  * ```
  */
 
-var renderSnapshot = exports.renderSnapshot = function renderSnapshot(component) {
-  return expect(global.renderToJSON(component)).toMatchSnapshot();
-};
+const renderSnapshot = component => expect(global.renderToJSON(component)).toMatchSnapshot();
 
 /**
  * Renders an async component and matches it against a snapshot.
@@ -52,45 +47,8 @@ var renderSnapshot = exports.renderSnapshot = function renderSnapshot(component)
  * })
  * ```
  */
-var renderSnapshotAsync = exports.renderSnapshotAsync = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(component) {
-    var _t2;
-    return _regenerator["default"].wrap(function (_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          _t2 = expect;
-          _context2.next = 1;
-          return global.act(/*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
-            var _t;
-            return _regenerator["default"].wrap(function (_context) {
-              while (1) switch (_context.prev = _context.next) {
-                case 0:
-                  _t = global;
-                  _context.next = 1;
-                  return component;
-                case 1:
-                  return _context.abrupt("return", _t.renderToJSON.call(_t, _context.sent));
-                case 2:
-                case "end":
-                  return _context.stop();
-              }
-            }, _callee);
-          })));
-        case 1:
-          _context2.next = 2;
-          return _t2(_context2.sent).toMatchSnapshot();
-        case 2:
-          return _context2.abrupt("return", _context2.sent);
-        case 3:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return function renderSnapshotAsync(_x) {
-    return _ref.apply(this, arguments);
-  };
-}();
+exports.renderSnapshot = renderSnapshot;
+const renderSnapshotAsync = async component => await expect(await global.act(async () => global.renderToJSON(await component))).toMatchSnapshot();
 
 /**
  * Creates a mock store with default configuration.
@@ -106,8 +64,8 @@ var renderSnapshotAsync = exports.renderSnapshotAsync = /*#__PURE__*/function ()
  * const store = createMockStore({ context: { cars: [] } })
  * ```
  */
-var createMockStore = exports.createMockStore = function createMockStore() {
-  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+exports.renderSnapshotAsync = renderSnapshotAsync;
+const createMockStore = (initialState = {}) => {
   // This is a placeholder - implement based on your store configuration
   // You may need to import from redux-mock-store or similar
   return initialState;
@@ -127,43 +85,14 @@ var createMockStore = exports.createMockStore = function createMockStore() {
  * await waitFor(() => element.textContent === 'Loaded', 2000)
  * ```
  */
-var waitFor = exports.waitFor = /*#__PURE__*/function () {
-  var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(condition) {
-    var timeout,
-      interval,
-      startTime,
-      _args3 = arguments;
-    return _regenerator["default"].wrap(function (_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
-        case 0:
-          timeout = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : 1000;
-          interval = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : 50;
-          startTime = Date.now();
-        case 1:
-          if (condition()) {
-            _context3.next = 4;
-            break;
-          }
-          if (!(Date.now() - startTime > timeout)) {
-            _context3.next = 2;
-            break;
-          }
-          throw new Error("Timeout waiting for condition after ".concat(timeout, "ms"));
-        case 2:
-          _context3.next = 3;
-          return new Promise(function (resolve) {
-            return setTimeout(resolve, interval);
-          });
-        case 3:
-          _context3.next = 1;
-          break;
-        case 4:
-        case "end":
-          return _context3.stop();
-      }
-    }, _callee3);
-  }));
-  return function waitFor(_x2) {
-    return _ref3.apply(this, arguments);
-  };
-}();
+exports.createMockStore = createMockStore;
+const waitFor = async (condition, timeout = 1000, interval = 50) => {
+  const startTime = Date.now();
+  while (!condition()) {
+    if (Date.now() - startTime > timeout) {
+      throw new Error(`Timeout waiting for condition after ${timeout}ms`);
+    }
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+};
+exports.waitFor = waitFor;

package/build/storybook/index.js

@@ -5,19 +5,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "getStorybookMainSetup", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mainSetup.getStorybookMainSetup;
   }
 });
 Object.defineProperty(exports, "getStorybookPreviewSetup", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _previewSetup.getStorybookPreviewSetup;
   }
 });
 Object.defineProperty(exports, "setStorybookManagerSetup", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _managerSetup.setStorybookManagerSetup;
   }
 });

package/build/storybook/mainSetup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainSetup.d.ts","sourceRoot":"","sources":["../../src/storybook/mainSetup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAOhE,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE;;;;CAAA,mBAiQ1E"}
+{"version":3,"file":"mainSetup.d.ts","sourceRoot":"","sources":["../../src/storybook/mainSetup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAOhE,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE;;;;CAAA,mBAoQ1E"}